From 7c214ea52efbcf12261128b458db8fe025cbc61b Mon Sep 17 00:00:00 2001 From: Michael Bommarito Date: Thu, 16 Apr 2026 13:40:35 -0400 Subject: [PATCH 1/6] gh-148653: Fix SIGSEGV in marshal.loads for self-referencing tuples --- Lib/test/test_marshal.py | 20 +++++++++++++++++++ ...-04-16-12-51-32.gh-issue-148653.G0_AMQ.rst | 2 ++ Python/marshal.c | 5 ++++- 3 files changed, 26 insertions(+), 1 deletion(-) create mode 100644 Misc/NEWS.d/next/Library/2026-04-16-12-51-32.gh-issue-148653.G0_AMQ.rst diff --git a/Lib/test/test_marshal.py b/Lib/test/test_marshal.py index 78db4219e2997c..477203a913476c 100644 --- a/Lib/test/test_marshal.py +++ b/Lib/test/test_marshal.py @@ -731,5 +731,25 @@ def test_read_object_from_file(self): os_helper.unlink(os_helper.TESTFN) +class SelfRefTupleTest(unittest.TestCase): + """Regression test for gh-148653: TYPE_TUPLE with FLAG_REF back-reference. + + R_REF registered the tuple in p->refs before its slots were populated. + A TYPE_REF back-reference to the partial tuple could reach a hashing + site (PySet_Add) with NULL slots, crashing with SIGSEGV. + + The fix uses the two-phase r_ref_reserve/r_ref_insert pattern so the + Py_None placeholder is detected by the TYPE_REF handler, raising + ValueError instead. + """ + + def test_self_ref_tuple(self): + # TYPE_TUPLE|FLAG_REF n=2; NONE; TYPE_SET n=1; TYPE_REF(0) + payload = (b'\xa8\x02\x00\x00\x00N' + b'<\x01\x00\x00\x00r\x00\x00\x00\x00') + with self.assertRaises(ValueError): + marshal.loads(payload) + + if __name__ == "__main__": unittest.main() diff --git a/Misc/NEWS.d/next/Library/2026-04-16-12-51-32.gh-issue-148653.G0_AMQ.rst b/Misc/NEWS.d/next/Library/2026-04-16-12-51-32.gh-issue-148653.G0_AMQ.rst new file mode 100644 index 00000000000000..d33a29705f7f6b --- /dev/null +++ b/Misc/NEWS.d/next/Library/2026-04-16-12-51-32.gh-issue-148653.G0_AMQ.rst @@ -0,0 +1,2 @@ +Fix SIGSEGV in :func:`marshal.loads` for self-referencing tuples. Such +payloads will now raise :exc:`ValueError` instead of crashing. diff --git a/Python/marshal.c b/Python/marshal.c index b60a36e128cd9f..8b4ab90700ebb4 100644 --- a/Python/marshal.c +++ b/Python/marshal.c @@ -1385,7 +1385,9 @@ r_object(RFILE *p) } _read_tuple: v = PyTuple_New(n); - R_REF(v); + idx = r_ref_reserve(flag, p); + if (idx < 0) + Py_CLEAR(v); if (v == NULL) break; @@ -1400,6 +1402,7 @@ r_object(RFILE *p) } PyTuple_SET_ITEM(v, i, v2); } + v = r_ref_insert(v, idx, flag, p); retval = v; break; From 38351499d915a61a71e9eeefe7b7af571c3a4e21 Mon Sep 17 00:00:00 2001 From: Michael Bommarito Date: Fri, 17 Apr 2026 12:48:32 -0400 Subject: [PATCH 2/6] marshal: preserve safe recursive hashable refs --- Include/internal/pycore_dict.h | 2 + Lib/test/test_marshal.py | 334 ++++++++++++++++++- Misc/marshal-recursive-ref-design.md | 464 +++++++++++++++++++++++++++ Objects/dictobject.c | 9 +- Python/marshal.c | 232 +++++++++++--- 5 files changed, 978 insertions(+), 63 deletions(-) create mode 100644 Misc/marshal-recursive-ref-design.md diff --git a/Include/internal/pycore_dict.h b/Include/internal/pycore_dict.h index 5cf3091dc88830..ef22a527678bce 100644 --- a/Include/internal/pycore_dict.h +++ b/Include/internal/pycore_dict.h @@ -423,6 +423,8 @@ typedef struct { Py_hash_t ma_hash; } PyFrozenDictObject; +#define _Py_FROZENDICT_HASH_CONSTRUCTING ((Py_hash_t)-2) + #define _PyFrozenDictObject_CAST(op) \ (assert(PyFrozenDict_Check(op)), _Py_CAST(PyFrozenDictObject*, (op))) diff --git a/Lib/test/test_marshal.py b/Lib/test/test_marshal.py index 477203a913476c..b84b6293630825 100644 --- a/Lib/test/test_marshal.py +++ b/Lib/test/test_marshal.py @@ -2,9 +2,11 @@ from test.support import is_apple_mobile, os_helper, requires_debug_ranges, is_emscripten from test.support.script_helper import assert_python_ok import array +import itertools import io import marshal import sys +import typing import unittest import os import types @@ -731,24 +733,322 @@ def test_read_object_from_file(self): os_helper.unlink(os_helper.TESTFN) -class SelfRefTupleTest(unittest.TestCase): - """Regression test for gh-148653: TYPE_TUPLE with FLAG_REF back-reference. - - R_REF registered the tuple in p->refs before its slots were populated. - A TYPE_REF back-reference to the partial tuple could reach a hashing - site (PySet_Add) with NULL slots, crashing with SIGSEGV. - - The fix uses the two-phase r_ref_reserve/r_ref_insert pattern so the - Py_None placeholder is detected by the TYPE_REF handler, raising - ValueError instead. - """ +WrapperTargetKind = typing.Literal["tuple", "slice", "frozendict"] +MutableTargetKind = typing.Literal["list", "dict_value"] +BridgeStepKind = typing.Literal["list", "dict_value"] +WrapperRootLayoutKind = typing.Literal[ + "target", "first_bridge", "outer_list_pair", "outer_dict_pair"] +MutableRootLayoutKind = typing.Literal["target", "outer_list", "outer_dict"] +BackrefMultiplicityKind = typing.Literal["single", "duplicate"] + + +class SemanticRecursiveCase(typing.NamedTuple): + name: str + min_version: int + build: typing.Callable[[], object] + + +class RecursivePayloadCase(typing.NamedTuple): + name: str + payload: bytes + expected: typing.Callable[[], object] + + +def _marshal_atomic_signature(value: object) -> tuple[str, object] | None: + if value is None: + return ("none", None) + if value is Ellipsis: + return ("ellipsis", None) + if value is StopIteration: + return ("stopiter", None) + if isinstance(value, bool): + return ("bool", value) + if isinstance(value, int): + return ("int", value) + if isinstance(value, float): + return ("float", value) + if isinstance(value, complex): + return ("complex", value) + if isinstance(value, str): + return ("str", value) + if isinstance(value, bytes): + return ("bytes", value) + return None + + +def _marshal_mapping_signature( + mapping: dict[object, object] | frozendict, + encode: typing.Callable[[object], object], +) -> tuple[tuple[tuple[str, object], object], ...]: + entries = [] + for key, value in mapping.items(): + key_sig = _marshal_atomic_signature(key) + if key_sig is None: + raise TypeError( + "recursive marshal test only supports atomic mapping keys") + entries.append((key_sig, encode(value))) + entries.sort() + return tuple(entries) + + +def _marshal_graph_signature(root: object) -> object: + seen: dict[int, int] = {} + nodes: list[object] = [] + + def encode(value: object) -> object: + atomic = _marshal_atomic_signature(value) + if atomic is not None: + return atomic + + obj_id = id(value) + if obj_id in seen: + return ("ref", seen[obj_id]) + + node_id = len(nodes) + seen[obj_id] = node_id + nodes.append(("pending",)) + + if isinstance(value, list): + node = ("list", tuple(encode(item) for item in value)) + elif isinstance(value, tuple): + node = ("tuple", tuple(encode(item) for item in value)) + elif isinstance(value, frozendict): + node = ("frozendict", _marshal_mapping_signature(value, encode)) + elif isinstance(value, dict): + node = ("dict", _marshal_mapping_signature(value, encode)) + elif isinstance(value, slice): + node = ("slice", ( + ("start", encode(value.start)), + ("stop", encode(value.stop)), + ("step", encode(value.step)), + )) + else: + raise TypeError( + f"unsupported recursive marshal test node type: {type(value)!r}") + + nodes[node_id] = node + return ("ref", node_id) + + return (encode(root), tuple(nodes)) + + +def _make_bridge(bridge_kind: BridgeStepKind) -> list[object] | dict[str, object]: + if bridge_kind == "list": + return [] + return {} + + +def _link_bridge(bridge_kind: BridgeStepKind, + bridge: list[object] | dict[str, object], + value: object, + multiplicity: BackrefMultiplicityKind) -> None: + if bridge_kind == "list": + bridge = typing.cast(list[object], bridge) + bridge.append(value) + if multiplicity == "duplicate": + bridge.append(value) + else: + bridge = typing.cast(dict[str, object], bridge) + bridge["x"] = value + if multiplicity == "duplicate": + bridge["y"] = value + + +def _build_wrapper_target( + target_kind: WrapperTargetKind, + bridge: list[object] | dict[str, object], +) -> object: + if target_kind == "tuple": + return (bridge,) + if target_kind == "slice": + return slice(None, bridge, None) + return frozendict({None: bridge}) + + +def _build_wrapper_recursive_case( + target_kind: WrapperTargetKind, + bridge_path: tuple[BridgeStepKind, ...], + root_layout: WrapperRootLayoutKind, + multiplicity: BackrefMultiplicityKind, +) -> object: + bridges = [_make_bridge(bridge_kind) for bridge_kind in bridge_path] + target = _build_wrapper_target(target_kind, bridges[0]) + for index, bridge_kind in enumerate(bridge_path[:-1]): + _link_bridge(bridge_kind, bridges[index], bridges[index + 1], "single") + _link_bridge(bridge_path[-1], bridges[-1], target, multiplicity) + + if root_layout == "target": + return target + if root_layout == "first_bridge": + return bridges[0] + if root_layout == "outer_list_pair": + return [target, bridges[-1]] + return {"target": target, "bridge": bridges[-1]} + + +def _build_mutable_recursive_case( + target_kind: MutableTargetKind, + root_layout: MutableRootLayoutKind, + multiplicity: BackrefMultiplicityKind, +) -> object: + if target_kind == "list": + target = [] + _link_bridge("list", target, target, multiplicity) + else: + target = {} + _link_bridge("dict_value", target, target, multiplicity) + + if root_layout == "target": + return target + if root_layout == "outer_list": + return [target] + return {"target": target} + + +def _iter_semantic_recursive_cases() -> typing.Iterator[SemanticRecursiveCase]: + mutable_target_kinds = typing.cast( + tuple[MutableTargetKind, ...], ("list", "dict_value")) + mutable_root_layouts = typing.cast( + tuple[MutableRootLayoutKind, ...], ("target", "outer_list", "outer_dict")) + wrapper_target_kinds = typing.cast( + tuple[WrapperTargetKind, ...], ("tuple", "slice", "frozendict")) + wrapper_root_layouts = typing.cast( + tuple[WrapperRootLayoutKind, ...], + ("target", "first_bridge", "outer_list_pair", "outer_dict_pair")) + multiplicities = typing.cast( + tuple[BackrefMultiplicityKind, ...], ("single", "duplicate")) + bridge_steps = typing.cast(tuple[BridgeStepKind, ...], ("list", "dict_value")) + bridge_paths = tuple( + typing.cast(tuple[BridgeStepKind, ...], bridge_path) + for path_len in (1, 2) + for bridge_path in itertools.product(bridge_steps, repeat=path_len) + ) + + for target_kind, root_layout, multiplicity in itertools.product( + mutable_target_kinds, mutable_root_layouts, multiplicities): + def build(target_kind: MutableTargetKind = target_kind, + root_layout: MutableRootLayoutKind = root_layout, + multiplicity: BackrefMultiplicityKind = multiplicity) -> object: + return _build_mutable_recursive_case( + target_kind, root_layout, multiplicity) + + yield SemanticRecursiveCase( + name=f"{target_kind}_self_{root_layout}_{multiplicity}", + min_version=3, + build=build, + ) + + for target_kind, bridge_path, root_layout, multiplicity in itertools.product( + wrapper_target_kinds, bridge_paths, wrapper_root_layouts, multiplicities): + if target_kind == "tuple": + min_version = 3 + elif target_kind == "slice": + min_version = 5 + else: + min_version = 6 + + def build(target_kind: WrapperTargetKind = target_kind, + bridge_path: tuple[BridgeStepKind, ...] = bridge_path, + root_layout: WrapperRootLayoutKind = root_layout, + multiplicity: BackrefMultiplicityKind = multiplicity) -> object: + return _build_wrapper_recursive_case( + target_kind, bridge_path, root_layout, multiplicity) + + bridge_path_name = "_".join(bridge_path) + yield SemanticRecursiveCase( + name=( + f"{target_kind}_via_{bridge_path_name}_" + f"{root_layout}_{multiplicity}" + ), + min_version=min_version, + build=build, + ) + + +def _iter_valid_recursive_payload_cases() -> typing.Iterator[RecursivePayloadCase]: + yield RecursivePayloadCase( + name="tuple_with_duplicate_backrefs_in_list_payload", + payload=(b'\xa9\x01' + b'[\x02\x00\x00\x00' + b'r\x00\x00\x00\x00' + b'r\x00\x00\x00\x00'), + expected=lambda: _build_wrapper_recursive_case( + "tuple", ("list",), "target", "duplicate"), + ) + yield RecursivePayloadCase( + name="root_list_with_inner_tuple_backref_payload", + payload=(b'\xdb\x02\x00\x00\x00' + b'\xa9\x01' + b'\xdb\x01\x00\x00\x00' + b'r\x01\x00\x00\x00' + b'r\x02\x00\x00\x00'), + expected=lambda: _build_wrapper_recursive_case( + "tuple", ("list",), "outer_list_pair", "single"), + ) + + +def _iter_invalid_recursive_payloads() -> typing.Iterator[tuple[str, bytes]]: + yield ( + "tuple_self_in_set", + b'\xa8\x02\x00\x00\x00N<\x01\x00\x00\x00r\x00\x00\x00\x00', + ) + yield ( + "tuple_direct_self_reference", + b'\xa9\x01r\x00\x00\x00\x00', + ) + yield ( + "tuple_as_incomplete_dict_key", + b'\xa9\x01{r\x00\x00\x00\x00N0', + ) + if marshal.version >= 5: + yield ( + "slice_direct_self_reference", + b'\xbaNr\x00\x00\x00\x00N', + ) + if marshal.version >= 6: + yield ( + "frozendict_direct_self_value", + b'\xfdNr\x00\x00\x00\x000', + ) + + +class RecursiveGraphTest(unittest.TestCase): + def assert_marshal_graph_roundtrip(self, sample: object, version: int) -> None: + expected = _marshal_graph_signature(sample) + loaded = marshal.loads(marshal.dumps(sample, version)) + self.assertEqual(expected, _marshal_graph_signature(loaded)) + try: + with open(os_helper.TESTFN, "wb") as file: + marshal.dump(sample, file, version) + with open(os_helper.TESTFN, "rb") as file: + loaded = marshal.load(file) + self.assertEqual(expected, _marshal_graph_signature(loaded)) + finally: + os_helper.unlink(os_helper.TESTFN) - def test_self_ref_tuple(self): - # TYPE_TUPLE|FLAG_REF n=2; NONE; TYPE_SET n=1; TYPE_REF(0) - payload = (b'\xa8\x02\x00\x00\x00N' - b'<\x01\x00\x00\x00r\x00\x00\x00\x00') - with self.assertRaises(ValueError): - marshal.loads(payload) + def test_constructible_recursive_case_count(self): + self.assertEqual(len(tuple(_iter_semantic_recursive_cases())), 156) + + def test_constructible_recursive_roundtrips(self): + for case in _iter_semantic_recursive_cases(): + for version in range(case.min_version, marshal.version + 1): + with self.subTest(case=case.name, version=version): + self.assert_marshal_graph_roundtrip(case.build(), version) + + def test_handpicked_recursive_payloads(self): + for case in _iter_valid_recursive_payload_cases(): + with self.subTest(case.name): + loaded = marshal.loads(case.payload) + self.assertEqual( + _marshal_graph_signature(case.expected()), + _marshal_graph_signature(loaded), + ) + + def test_invalid_recursive_payloads(self): + for name, payload in _iter_invalid_recursive_payloads(): + with self.subTest(name): + with self.assertRaises(ValueError): + marshal.loads(payload) if __name__ == "__main__": diff --git a/Misc/marshal-recursive-ref-design.md b/Misc/marshal-recursive-ref-design.md new file mode 100644 index 00000000000000..bb2aac9c4b2a1c --- /dev/null +++ b/Misc/marshal-recursive-ref-design.md @@ -0,0 +1,464 @@ +# Marshal Recursive Reference Design + +## Problem + +`marshal.loads()` currently mixes two incompatible strategies for recursive +objects: + +- Some object types publish themselves into the reference table before they are + fully initialized. +- Other object types reserve a reference slot and only publish the object after + all children are loaded. + +The early-publication path preserves some valid recursive graphs produced by +`marshal.dumps()`, but it can expose partially initialized hashable containers +to hashing sites such as `PySet_Add()` and `PyDict_SetItem()`. + +The delayed-publication path avoids the crash, but it rejects valid recursive +graphs emitted by normal Python code, such as: + +- `a = ([],); a[0].append(a)` +- `s = slice([]); s.stop.append(s)` +- `fd = frozendict({None: []}); fd[None].append(fd)` + +The core requirement is therefore: + +1. Preserve valid recursive graphs emitted by `marshal.dumps()`. +2. Reject crafted byte streams that would observe an incomplete hashable object + in an unsafe position. +3. Keep the acyclic fast path close to the current implementation. + +## Design Summary + +Use a stateful reference table during unmarshalling. + +Each reference-table entry has: + +- the object pointer stored in `p->refs` +- a small parallel state byte + +The state is one of: + +- `REF_READY`: the entry is fully initialized and may be returned anywhere +- `REF_RESERVED`: a placeholder entry with no published object yet +- `REF_INCOMPLETE_HASHABLE`: the entry points to a real object shell that is + not yet fully initialized and must not be returned in all contexts + +The read side also carries a simple caller policy: + +- `allow_incomplete_hashable = 1` +- `allow_incomplete_hashable = 0` + +This is not a whole-graph algorithm. It is an incremental state machine: + +- mutable containers remain on the current fast path +- only a small set of hashable recursive containers use the incomplete state +- `TYPE_REF` becomes context-sensitive + +## Context Rule + +`TYPE_REF` may return an incomplete hashable object only when the caller is +loading a plain value position that does not itself require the target to be +finalized. + +Allowed: + +- list elements +- dict values + +Rejected: + +- tuple elements +- slice fields +- dict keys +- set elements +- frozenset elements +- frozendict values +- frozendict keys + +This rule preserves the valid recursive cases that arise in normal Python code: + +- tuple/slice/frozendict back-references through a list element +- tuple back-references through a dict value + +It also rejects the fabricated cases that directly embed an incomplete hashable +object inside another hash-sensitive or immutable position, such as: + +- direct self-containing tuple +- direct self-containing slice +- direct self-containing frozendict value +- set or dict-key uses of incomplete tuple/slice/frozendict + +## Type Policy + +### Keep current eager publication + +These types are already safe to publish immediately because they are mutable and +unhashable: + +- `TYPE_LIST` +- `TYPE_DICT` +- `TYPE_SET` + +They continue to use the current eager publication path and are marked +`REF_READY` immediately. + +### Publish early, but mark incomplete + +These types need to be referenceable before all children are loaded in order to +preserve valid recursive graphs, but they must not be observed everywhere while +incomplete: + +- `TYPE_TUPLE` +- `TYPE_SLICE` +- `TYPE_FROZENDICT` + +Algorithm: + +1. Allocate the object shell. +2. Publish it into `p->refs`. +3. Mark the entry `REF_INCOMPLETE_HASHABLE`. +4. Load child objects using the context rule above. +5. When initialization completes, mark the entry `REF_READY`. + +### Keep delayed publication + +These types remain delayed: + +- `TYPE_FROZENSET` +- `TYPE_CODE` + +Reasons: + +- `TYPE_CODE` already uses reserve/insert and does not need recursive exposure. +- `TYPE_FROZENSET` relies on `PySet_Add()` allowing mutation only while the + object is effectively brand new. We should not change that path unless we can + demonstrate a real Python-emittable recursive graph that requires it. + +## Frozendict Construction + +`TYPE_FROZENDICT` cannot keep the current `dict`-then-wrap strategy, because +back-references see the wrong identity and type. + +Instead: + +1. Create a real empty `frozendict`. +2. Mark it as "under marshal construction". +3. Publish it as `REF_INCOMPLETE_HASHABLE`. +4. Insert items directly into the frozendict using the internal dict insertion + path. +5. Clear the construction marker and mark the ref-table entry `REF_READY`. + +Implementation note: + +- `frozendict` already shares dict storage layout. +- The loader should use an internal sentinel state on `ma_hash` during + construction so dict internals can distinguish: + - normal immutable frozendict + - marshal-only under-construction frozendict + +This preserves the correct identity for recursive values while avoiding the +current "nested dict instead of frozendict" behavior. + +## Data Structures + +Add to `RFILE`: + +```c +PyObject *refs; // existing list of strong references +uint8_t *ref_states; // parallel state table +Py_ssize_t refs_allocated; +``` + +State enum: + +```c +typedef enum { + REF_READY = 0, + REF_RESERVED = 1, + REF_INCOMPLETE_HASHABLE = 2, +} RefState; +``` + +## Reader Flow + +```mermaid +flowchart TD + A[Read type byte] --> B{FLAG_REF?} + B -- no --> C[Load object normally] + B -- yes --> D{Type policy} + D -- eager-ready --> E[Create object] + E --> F[Publish ref as REF_READY] + F --> G[Load children] + D -- early-incomplete --> H[Create object shell] + H --> I[Publish ref as REF_INCOMPLETE_HASHABLE] + I --> J[Load children with context rules] + J --> K[Mark ref REF_READY] + D -- delayed --> L[Reserve ref slot as REF_RESERVED] + L --> M[Load children] + M --> N[Insert object and mark REF_READY] + G --> O[Return object] + K --> O + N --> O + + P[Read TYPE_REF] --> Q{Entry state} + Q -- REF_READY --> R[Return referenced object] + Q -- REF_RESERVED --> S[Raise ValueError invalid reference] + Q -- REF_INCOMPLETE_HASHABLE --> T{Caller allows incomplete hashable?} + T -- yes --> R + T -- no --> S +``` + +## Call-Site Policy + +Use `r_object(p, allow_incomplete_hashable)`. + +Recommended call policy: + +- list element: `1` +- dict value: `1` +- everything else: `0` + +That gives the smallest rule set that still preserves the known valid recursive +graphs from normal Python code. + +## Why This Is Efficient + +Fast-path properties: + +- Acyclic objects do not hit `TYPE_REF` back-edges, so the added work is just a + small state write per referenced object and a branch in `TYPE_REF`. +- Mutable recursive containers keep their current eager behavior. +- No whole-stream pre-scan or SCC computation is needed. +- The ref-state table is a byte array indexed in parallel with `p->refs`. + +The algorithm is therefore still linear in the number of objects and edges in +the stream, with low constant-factor overhead. + +## Why This Is Safer + +The invariant becomes: + +> An incomplete hashable object may exist in the reference table, but it may +> only be returned through contexts that do not immediately require its final +> hash-sensitive invariants to hold. + +This blocks the crash class directly: + +- set insertion of incomplete tuple/slice/frozendict +- dict-key insertion of incomplete tuple/slice/frozendict + +And it avoids direct immutable self-cycles that are only possible through +crafted marshal bytes. + +## Semantic Round-Trip Generator + +Serhiy's review point changes how the positive test suite should be framed. + +The primary compatibility question is not: + +> "Which byte streams should the loader accept?" + +It is: + +> "Which object graphs can Python construct today and `marshal.dumps()` emit, +> and does `marshal.loads()` reconstruct the same graph?" + +That means the positive suite should start from Python-valid construction +programs, not from raw marshal payloads. Raw payloads still matter, but mainly +for negative tests and boundary-policy tests. + +### Program Model + +The bounded positive generator uses only exact marshal-supported container +types, and only construction orders that Python can actually execute: + +1. Allocate one or two mutable bridge shells: + - `list` + - `dict` +2. Create one recursive wrapper target whose first outgoing edge points at the + first mutable bridge: + - `tuple((bridge0,))` + - `slice(None, bridge0, None)` + - `frozendict({None: bridge0})` +3. Populate the bridge chain using only Python-valid mutable operations: + - list element insertion + - dict value insertion +4. Close the cycle by storing the target back into the terminal bridge once or + twice. +5. Optionally expose the graph through a few root layouts to vary traversal and + aliasing: + - the target itself + - the first bridge itself + - an outer list `[target, terminal_bridge]` + - an outer dict `{"target": target, "bridge": terminal_bridge}` +6. Separately generate pure mutable self-cycles: + - list containing itself + - dict value containing itself + +This is the executable grammar used by the test generator: + +```text +BridgeStep ::= list | dict_value + +WrapperTarget ::= + tuple(bridge0) + | slice(None, bridge0, None) + | frozendict({None: bridge0}) + +BridgePath ::= + bridge0 + | bridge0 -> bridge1 + +TerminalBackref ::= + target + | target, target + +WrapperRoot ::= + target + | first_bridge + | [target, terminal_bridge] + | {"target": target, "bridge": terminal_bridge} + +MutableSelf ::= + list(self) + | dict_value(self) + +MutableRoot ::= + target + | [target] + | {"target": target} +``` + +And this is the positive-test pipeline: + +```mermaid +flowchart LR + A[Choose bounded Python-valid program] --> B[Build live object graph in Python] + B --> C[Compute canonical graph signature] + B --> D[marshal.dumps for each supported version] + D --> E[marshal.loads and marshal.load] + E --> F[Compute loaded graph signature] + C --> G{Signatures equal?} + F --> G + G -- yes --> H[Compatibility preserved] + G -- no --> I[Round-trip regression] +``` + +The corresponding test code lives in `Lib/test/test_marshal.py` and generates: + +- `2 * 3 * 2 = 12` mutable self-cycle programs +- `3 * (2 + 4) * 4 * 2 = 144` wrapper-target programs + +for a total of `156` Python-valid recursive programs before version expansion. + +### Why This Bound Is Meaningful + +This is a bounded search, not a proof over all Python programs. The bound is +chosen so that every locally distinct recursive construction pattern relevant to +this bug appears at least once. + +The key observation is: + +- A Python-valid recursive `tuple`, `slice`, or `frozendict` cannot close a + cycle by mutating itself. +- Therefore any cycle involving one of those targets must pass through at least + one mutable bridge. +- The only bridge edge kinds that Python can use to close such cycles are: + - list element + - dict value + +So the safety-relevant local shape is: + +```text +wrapper target -> mutable bridge chain -> TYPE_REF back to wrapper target +``` + +The policy decision in the loader depends on the edge kind at the `TYPE_REF` +site, not on the absolute graph diameter. Once a safe back-edge through a list +element or dict value is covered, adding more safe mutable hops does not create +a new loader policy. It only composes already-covered edge kinds. + +That is why the generator stops at bridge-path lengths 1 and 2: + +- length 1 covers the minimal SCC that exercises the back-edge directly +- length 2 covers indirection, non-root targets, and nested bridge identity +- longer paths repeat the same safe edge kinds without introducing a new + `TYPE_REF` context + +### Canonical Graph Oracle + +Positive round-trip tests must check more than equality. Equality will not catch +all regressions that matter here: + +- lost aliasing +- broken cycles +- type corruption such as `frozendict` loading back as `dict` +- accidental graph duplication + +So the test suite compares a canonical graph signature of the original and +loaded objects. + +The signature records: + +- node kind: `list`, `tuple`, `dict`, `frozendict`, `slice`, or atomic value +- ordered outgoing edges for sequence-like nodes +- labeled `start/stop/step` edges for `slice` +- sorted atomic-key/value edges for mappings +- back-references by canonical node id + +This gives a deterministic structural fingerprint for the reachable object graph +from the chosen root. It is not a formal bisimulation proof, but it is strong +enough to catch the classes of regression this refactor risks. + +### Positive vs Negative Coverage + +The suite is intentionally split in two: + +1. Positive semantic generator: + - starts from Python-valid construction programs + - checks graph-shape preservation after `dumps`/`loads` + - runs across every marshal version that supports the target type +2. Negative raw-payload tests: + - start from crafted byte streams that normal Python code cannot produce + - verify that unsafe observations of incomplete objects raise `ValueError` + - guard directly against the SIGSEGV class and related malformed-reference + cases + +Keeping those two buckets separate makes the review story clearer: + +- semantic tests protect compatibility +- payload tests protect safety + +## Test Strategy + +Tests should cover four buckets: + +1. Python-valid recursive round-trips generated from the bounded semantic model: + - mutable self-cycles + - wrapper targets through list bridges + - wrapper targets through dict-value bridges + - duplicate back-references in terminal bridges + - non-root targets and aliasing roots + - all supported marshal versions for each target type + +2. Crafted invalid payloads that should raise `ValueError`: + - tuple direct self-reference + - tuple in set element while incomplete + - slice direct self-reference + - frozendict direct self-reference in value + +3. Shared-reference non-recursive cases: + - ensure ordinary instancing behavior is unchanged + +4. Performance sanity: + - acyclic small tuple + - nested dict/list payload + - code object payload + +## Non-Goals + +- Do not add a whole-graph pre-scan. +- Do not change the marshal wire format. +- Do not broaden `frozenset` recursion support without a demonstrated + Python-emittable use case. diff --git a/Objects/dictobject.c b/Objects/dictobject.c index 483bddebb9949f..cf3f26480e479c 100644 --- a/Objects/dictobject.c +++ b/Objects/dictobject.c @@ -296,7 +296,9 @@ can_modify_dict(PyDictObject *mp) if (PyFrozenDict_Check(mp)) { // No locking required to modify a newly created frozendict // since it's only accessible from the current thread. - return PyUnstable_Object_IsUniquelyReferenced(_PyObject_CAST(mp)); + PyFrozenDictObject *frozen = (PyFrozenDictObject *)mp; + return frozen->ma_hash == _Py_FROZENDICT_HASH_CONSTRUCTING || + PyUnstable_Object_IsUniquelyReferenced(_PyObject_CAST(mp)); } else { // Locking is only required if the dictionary is not @@ -8206,6 +8208,11 @@ frozendict_hash(PyObject *op) { PyFrozenDictObject *self = _PyFrozenDictObject_CAST(op); Py_hash_t shash = FT_ATOMIC_LOAD_SSIZE_RELAXED(self->ma_hash); + if (shash == _Py_FROZENDICT_HASH_CONSTRUCTING) { + PyErr_SetString(PyExc_ValueError, + "cannot hash frozendict during marshal construction"); + return -1; + } if (shash != -1) { return shash; } diff --git a/Python/marshal.c b/Python/marshal.c index 8b4ab90700ebb4..6da825f8b700a0 100644 --- a/Python/marshal.c +++ b/Python/marshal.c @@ -9,6 +9,7 @@ #include "Python.h" #include "pycore_call.h" // _PyObject_CallNoArgs() #include "pycore_code.h" // _PyCode_New() +#include "pycore_dict.h" // _PyDict_SetItem_Take2() #include "pycore_hashtable.h" // _Py_hashtable_t #include "pycore_long.h" // _PyLong_IsZero() #include "pycore_object.h" // _PyObject_IsUniquelyReferenced @@ -798,9 +799,17 @@ typedef struct { char *buf; Py_ssize_t buf_size; PyObject *refs; /* a list */ + uint8_t *ref_states; /* parallel table for refs */ + Py_ssize_t refs_allocated; int allow_code; } RFILE; +typedef enum { + REF_STATE_READY = 0, + REF_STATE_RESERVED = 1, + REF_STATE_INCOMPLETE_HASHABLE = 2, +} RefState; + static const char * r_string(Py_ssize_t n, RFILE *p) { @@ -872,6 +881,33 @@ r_string(Py_ssize_t n, RFILE *p) return p->buf; } +static int +r_ref_ensure_capacity(RFILE *p, Py_ssize_t needed) +{ + if (needed <= p->refs_allocated) { + return 0; + } + + Py_ssize_t allocated = p->refs_allocated ? p->refs_allocated : 16; + while (allocated < needed) { + if (allocated > PY_SSIZE_T_MAX / 2) { + PyErr_NoMemory(); + return -1; + } + allocated *= 2; + } + + uint8_t *states = PyMem_Realloc(p->ref_states, allocated * sizeof(*states)); + if (states == NULL) { + PyErr_NoMemory(); + return -1; + } + + p->ref_states = states; + p->refs_allocated = allocated; + return 0; +} + static int r_byte(RFILE *p) { @@ -1093,13 +1129,36 @@ r_ref_reserve(int flag, RFILE *p) PyErr_SetString(PyExc_ValueError, "bad marshal data (index list too large)"); return -1; } + if (r_ref_ensure_capacity(p, idx + 1) < 0) { + return -1; + } if (PyList_Append(p->refs, Py_None) < 0) return -1; + p->ref_states[idx] = REF_STATE_RESERVED; return idx; } else return 0; } +static void +r_ref_publish(PyObject *o, Py_ssize_t idx, int flag, RefState state, RFILE *p) +{ + if (flag) { + PyObject *tmp = PyList_GET_ITEM(p->refs, idx); + PyList_SET_ITEM(p->refs, idx, Py_NewRef(o)); + Py_DECREF(tmp); + p->ref_states[idx] = state; + } +} + +static void +r_ref_mark_ready(Py_ssize_t idx, int flag, RFILE *p) +{ + if (flag) { + p->ref_states[idx] = REF_STATE_READY; + } +} + /* insert the new object 'o' to the reflist at previously * allocated index 'idx'. * 'o' can be NULL, in which case nothing is done. @@ -1112,9 +1171,7 @@ static PyObject * r_ref_insert(PyObject *o, Py_ssize_t idx, int flag, RFILE *p) { if (o != NULL && flag) { /* currently only FLAG_REF is defined */ - PyObject *tmp = PyList_GET_ITEM(p->refs, idx); - PyList_SET_ITEM(p->refs, idx, Py_NewRef(o)); - Py_DECREF(tmp); + r_ref_publish(o, idx, flag, REF_STATE_READY, p); } return o; } @@ -1129,15 +1186,31 @@ r_ref(PyObject *o, int flag, RFILE *p) assert(flag & FLAG_REF); if (o == NULL) return NULL; - if (PyList_Append(p->refs, o) < 0) { + Py_ssize_t idx = r_ref_reserve(flag, p); + if (idx < 0) { Py_DECREF(o); /* release the new object */ return NULL; } + r_ref_publish(o, idx, flag, REF_STATE_READY, p); return o; } static PyObject * -r_object(RFILE *p) +r_new_slice_shell(void) +{ + PySliceObject *slice = PyObject_GC_New(PySliceObject, &PySlice_Type); + if (slice == NULL) { + return NULL; + } + slice->start = Py_NewRef(Py_None); + slice->stop = Py_NewRef(Py_None); + slice->step = Py_NewRef(Py_None); + PyObject_GC_Track(slice); + return (PyObject *)slice; +} + +static PyObject * +r_object(RFILE *p, int allow_incomplete_hashable) { /* NULL is a valid return value, it does not necessarily means that an exception is set. */ @@ -1390,9 +1463,12 @@ r_object(RFILE *p) Py_CLEAR(v); if (v == NULL) break; + if (flag) { + r_ref_publish(v, idx, flag, REF_STATE_INCOMPLETE_HASHABLE, p); + } for (i = 0; i < n; i++) { - v2 = r_object(p); + v2 = r_object(p, 0); if ( v2 == NULL ) { if (!PyErr_Occurred()) PyErr_SetString(PyExc_TypeError, @@ -1402,7 +1478,9 @@ r_object(RFILE *p) } PyTuple_SET_ITEM(v, i, v2); } - v = r_ref_insert(v, idx, flag, p); + if (flag && v != NULL) { + r_ref_mark_ready(idx, flag, p); + } retval = v; break; @@ -1420,7 +1498,7 @@ r_object(RFILE *p) if (v == NULL) break; for (i = 0; i < n; i++) { - v2 = r_object(p); + v2 = r_object(p, 1); if ( v2 == NULL ) { if (!PyErr_Occurred()) PyErr_SetString(PyExc_TypeError, @@ -1434,17 +1512,16 @@ r_object(RFILE *p) break; case TYPE_DICT: - case TYPE_FROZENDICT: v = PyDict_New(); R_REF(v); if (v == NULL) break; for (;;) { PyObject *key, *val; - key = r_object(p); + key = r_object(p, 0); if (key == NULL) break; - val = r_object(p); + val = r_object(p, 1); if (val == NULL) { Py_DECREF(key); break; @@ -1460,13 +1537,42 @@ r_object(RFILE *p) if (PyErr_Occurred()) { Py_CLEAR(v); } - if (type == TYPE_FROZENDICT && v != NULL) { - PyObject *frozendict = PyFrozenDict_New(v); - if (frozendict != NULL) { - Py_SETREF(v, frozendict); + retval = v; + break; + + case TYPE_FROZENDICT: + v = PyFrozenDict_New(NULL); + idx = r_ref_reserve(flag, p); + if (idx < 0) + Py_CLEAR(v); + if (v == NULL) + break; + _PyFrozenDictObject_CAST(v)->ma_hash = _Py_FROZENDICT_HASH_CONSTRUCTING; + if (flag) { + r_ref_publish(v, idx, flag, REF_STATE_INCOMPLETE_HASHABLE, p); + } + for (;;) { + PyObject *key, *val; + key = r_object(p, 0); + if (key == NULL) + break; + val = r_object(p, 0); + if (val == NULL) { + Py_DECREF(key); + break; } - else { + if (_PyDict_SetItem_Take2((PyDictObject *)v, key, val) < 0) { Py_CLEAR(v); + break; + } + } + if (PyErr_Occurred()) { + Py_CLEAR(v); + } + if (v != NULL) { + _PyFrozenDictObject_CAST(v)->ma_hash = -1; + if (flag) { + r_ref_mark_ready(idx, flag, p); } } retval = v; @@ -1507,7 +1613,7 @@ r_object(RFILE *p) break; for (i = 0; i < n; i++) { - v2 = r_object(p); + v2 = r_object(p, 0); if ( v2 == NULL ) { if (!PyErr_Occurred()) PyErr_SetString(PyExc_TypeError, @@ -1576,37 +1682,37 @@ r_object(RFILE *p) flags = (int)r_long(p); if (flags == -1 && PyErr_Occurred()) goto code_error; - code = r_object(p); + code = r_object(p, 0); if (code == NULL) goto code_error; - consts = r_object(p); + consts = r_object(p, 0); if (consts == NULL) goto code_error; - names = r_object(p); + names = r_object(p, 0); if (names == NULL) goto code_error; - localsplusnames = r_object(p); + localsplusnames = r_object(p, 0); if (localsplusnames == NULL) goto code_error; - localspluskinds = r_object(p); + localspluskinds = r_object(p, 0); if (localspluskinds == NULL) goto code_error; - filename = r_object(p); + filename = r_object(p, 0); if (filename == NULL) goto code_error; - name = r_object(p); + name = r_object(p, 0); if (name == NULL) goto code_error; - qualname = r_object(p); + qualname = r_object(p, 0); if (qualname == NULL) goto code_error; firstlineno = (int)r_long(p); if (firstlineno == -1 && PyErr_Occurred()) break; - linetable = r_object(p); + linetable = r_object(p, 0); if (linetable == NULL) goto code_error; - exceptiontable = r_object(p); + exceptiontable = r_object(p, 0); if (exceptiontable == NULL) goto code_error; @@ -1675,7 +1781,12 @@ r_object(RFILE *p) break; } v = PyList_GET_ITEM(p->refs, n); - if (v == Py_None) { + if (p->ref_states[n] == REF_STATE_RESERVED || v == Py_None) { + PyErr_SetString(PyExc_ValueError, "bad marshal data (invalid reference)"); + break; + } + if (p->ref_states[n] == REF_STATE_INCOMPLETE_HASHABLE && + !allow_incomplete_hashable) { PyErr_SetString(PyExc_ValueError, "bad marshal data (invalid reference)"); break; } @@ -1684,30 +1795,42 @@ r_object(RFILE *p) case TYPE_SLICE: { - Py_ssize_t idx = r_ref_reserve(flag, p); + PySliceObject *slice; + v = r_new_slice_shell(); + idx = r_ref_reserve(flag, p); if (idx < 0) { + Py_CLEAR(v); break; } - PyObject *stop = NULL; - PyObject *step = NULL; - PyObject *start = r_object(p); + if (v == NULL) { + break; + } + slice = (PySliceObject *)v; + if (flag) { + r_ref_publish(v, idx, flag, REF_STATE_INCOMPLETE_HASHABLE, p); + } + PyObject *start = r_object(p, 0); if (start == NULL) { - goto cleanup; + Py_CLEAR(v); + break; } - stop = r_object(p); + Py_SETREF(slice->start, start); + PyObject *stop = r_object(p, 0); if (stop == NULL) { - goto cleanup; + Py_CLEAR(v); + break; } - step = r_object(p); + Py_SETREF(slice->stop, stop); + PyObject *step = r_object(p, 0); if (step == NULL) { - goto cleanup; - } - retval = PySlice_New(start, stop, step); - r_ref_insert(retval, idx, flag, p); - cleanup: - Py_XDECREF(start); - Py_XDECREF(stop); - Py_XDECREF(step); + Py_CLEAR(v); + break; + } + Py_SETREF(slice->step, step); + if (flag) { + r_ref_mark_ready(idx, flag, p); + } + retval = v; break; } @@ -1739,7 +1862,7 @@ read_object(RFILE *p) return NULL; } } - v = r_object(p); + v = r_object(p, 0); if (v == NULL && !PyErr_Occurred()) PyErr_SetString(PyExc_TypeError, "NULL object in marshal data for object"); return v; @@ -1755,6 +1878,9 @@ PyMarshal_ReadShortFromFile(FILE *fp) rf.fp = fp; rf.end = rf.ptr = NULL; rf.buf = NULL; + rf.refs = NULL; + rf.ref_states = NULL; + rf.refs_allocated = 0; res = r_short(&rf); if (rf.buf != NULL) PyMem_Free(rf.buf); @@ -1770,6 +1896,9 @@ PyMarshal_ReadLongFromFile(FILE *fp) rf.readable = NULL; rf.ptr = rf.end = NULL; rf.buf = NULL; + rf.refs = NULL; + rf.ref_states = NULL; + rf.refs_allocated = 0; res = r_long(&rf); if (rf.buf != NULL) PyMem_Free(rf.buf); @@ -1833,11 +1962,14 @@ PyMarshal_ReadObjectFromFile(FILE *fp) rf.depth = 0; rf.ptr = rf.end = NULL; rf.buf = NULL; + rf.ref_states = NULL; + rf.refs_allocated = 0; rf.refs = PyList_New(0); if (rf.refs == NULL) return NULL; result = read_object(&rf); Py_DECREF(rf.refs); + PyMem_Free(rf.ref_states); if (rf.buf != NULL) PyMem_Free(rf.buf); return result; @@ -1855,11 +1987,14 @@ PyMarshal_ReadObjectFromString(const char *str, Py_ssize_t len) rf.end = str + len; rf.buf = NULL; rf.depth = 0; + rf.ref_states = NULL; + rf.refs_allocated = 0; rf.refs = PyList_New(0); if (rf.refs == NULL) return NULL; result = read_object(&rf); Py_DECREF(rf.refs); + PyMem_Free(rf.ref_states); if (rf.buf != NULL) PyMem_Free(rf.buf); return result; @@ -2013,9 +2148,12 @@ marshal_load_impl(PyObject *module, PyObject *file, int allow_code) rf.readable = file; rf.ptr = rf.end = NULL; rf.buf = NULL; + rf.ref_states = NULL; + rf.refs_allocated = 0; if ((rf.refs = PyList_New(0)) != NULL) { result = read_object(&rf); Py_DECREF(rf.refs); + PyMem_Free(rf.ref_states); if (rf.buf != NULL) PyMem_Free(rf.buf); } else @@ -2082,10 +2220,14 @@ marshal_loads_impl(PyObject *module, Py_buffer *bytes, int allow_code) rf.ptr = s; rf.end = s + n; rf.depth = 0; + rf.buf = NULL; + rf.ref_states = NULL; + rf.refs_allocated = 0; if ((rf.refs = PyList_New(0)) == NULL) return NULL; result = read_object(&rf); Py_DECREF(rf.refs); + PyMem_Free(rf.ref_states); return result; } From eb1c4b7ce46a2d49710e7ac687d5e59bb6b83207 Mon Sep 17 00:00:00 2001 From: Michael Bommarito Date: Fri, 17 Apr 2026 13:49:32 -0400 Subject: [PATCH 3/6] marshal: add benchmark summary note --- Misc/marshal-recursive-ref-design.md | 102 +++++++++++++++++++++++++++ 1 file changed, 102 insertions(+) diff --git a/Misc/marshal-recursive-ref-design.md b/Misc/marshal-recursive-ref-design.md index bb2aac9c4b2a1c..6c77a576ff8980 100644 --- a/Misc/marshal-recursive-ref-design.md +++ b/Misc/marshal-recursive-ref-design.md @@ -456,6 +456,108 @@ Tests should cover four buckets: - nested dict/list payload - code object payload +## Benchmark Summary + +This section records the cleaner performance rerun taken after the earlier +noisy measurements. + +Baseline commit: + +- `7c214ea52efbcf12261128b458db8fe025cbc61b` + +Current commit: + +- `38351499d915a61a71e9eeefe7b7af571c3a4e21` + +### Method + +Two benchmark layers were rerun: + +1. Targeted `pyperformance` comparison: + - baseline and current interpreters built locally + - `pyperformance run --affinity 0` + - current run used `--same-loops` from the baseline JSON + - benchmark slice: + `python_startup, python_startup_no_site, pickle, pickle_dict, + pickle_list, pickle_pure_python, unpickle, unpickle_list, + unpickle_pure_python, unpack_sequence` +2. Direct marshal microbenches: + - both interpreters pinned with `taskset -c 0` + - 11 repeats per benchmark + - loop counts increased by 10x over the earlier quick pass + - report medians as the primary statistic, with mins retained in the raw + JSON artifacts + +Artifacts: + +- `/tmp/pyperf-baseline-targeted-rerun.json` +- `/tmp/pyperf-current-targeted-rerun.json` +- `/tmp/marshal-baseline-stable.json` +- `/tmp/marshal-current-stable.json` + +### Targeted pyperformance + +The official targeted `pyperformance` slice is effectively flat. The earlier +`python_startup` regression did not reproduce under the cleaner rerun. + +| Benchmark | Baseline | Current | Delta | Significance | +| --- | ---: | ---: | ---: | --- | +| `python_startup` | `6.64 ms +- 0.28 ms` | `6.61 ms +- 0.09 ms` | `1.00x faster` | not significant | +| `python_startup_no_site` | `4.24 ms +- 0.09 ms` | `4.14 ms +- 0.05 ms` | `1.02x faster` | significant | +| `pickle` | `6.95 us +- 0.07 us` | `6.98 us +- 0.07 us` | `1.01x slower` | not significant | +| `pickle_dict` | `16.4 us +- 0.3 us` | `16.3 us +- 0.4 us` | `1.00x faster` | not significant | +| `pickle_list` | `2.64 us +- 0.04 us` | `2.63 us +- 0.06 us` | `1.01x faster` | not significant | +| `pickle_pure_python` | `182 us +- 3 us` | `183 us +- 2 us` | `1.00x slower` | not significant | +| `unpickle` | `8.66 us +- 0.26 us` | `8.51 us +- 0.20 us` | `1.02x faster` | not significant | +| `unpickle_list` | `2.64 us +- 0.03 us` | `2.69 us +- 0.07 us` | `1.02x slower` | not significant | +| `unpickle_pure_python` | `122 us +- 2 us` | `120 us +- 1 us` | `1.01x faster` | not significant | +| `unpack_sequence` | `20.5 ns +- 0.4 ns` | `20.0 ns +- 0.2 ns` | `1.02x faster` | significant | + +Interpretation: + +- No marshal-adjacent benchmark in this official slice shows a statistically + significant regression. +- The earlier `python_startup` slowdown was not stable. +- The two significant wins are small and likely unrelated to marshal itself. + +### Direct marshal microbenches + +The direct marshal-focused microbenches are more sensitive to this change than +the broader `pyperformance` slice. Here the load path remains consistently +slower, while dumps stay close to flat. + +Median results from the pinned stable rerun: + +| Benchmark | Operation | Baseline median | Current median | Delta | +| --- | --- | ---: | ---: | ---: | +| `small_tuple` | `loads` | `0.028996168 s` | `0.032467121 s` | `+12.0%` | +| `small_tuple` | `dumps` | `0.015875994 s` | `0.015498953 s` | `-2.4%` | +| `nested_dict` | `loads` | `0.077889564 s` | `0.085107413 s` | `+9.3%` | +| `nested_dict` | `dumps` | `0.072245140 s` | `0.073205785 s` | `+1.3%` | +| `code_obj` | `loads` | `0.090201660 s` | `0.097551488 s` | `+8.1%` | +| `code_obj` | `dumps` | `0.039133891 s` | `0.039431035 s` | `+0.8%` | + +Load-path deltas from the same rerun using the best observed sample were +similar: + +- `small_tuple` loads: `+12.5%` +- `nested_dict` loads: `+9.3%` +- `code_obj` loads: `+6.9%` + +### Conclusion + +The benchmark story is mixed but clear: + +- The broader targeted `pyperformance` slice does not show a stable + user-visible regression. +- The marshal-specific hot path does show a repeatable load slowdown of roughly + `7%` to `12%` on the synthetic microbenches above. +- Dump performance is approximately flat. + +So this design currently looks behaviorally correct and broadly acceptable at +the application level, but it is not yet honest to call it performance-neutral +for marshal's load fast path. + ## Non-Goals - Do not add a whole-graph pre-scan. From 4aaf064344d59b668b1e22ee05acee86c4dae9c0 Mon Sep 17 00:00:00 2001 From: Michael Bommarito Date: Fri, 17 Apr 2026 14:20:30 -0400 Subject: [PATCH 4/6] marshal: recover loads regression with raw refs table + tagged state Replace the PyList-backed reference table with a raw growable PyObject ** array, and encode REF_STATE_INCOMPLETE_HASHABLE in the low bit of each ref pointer so the parallel state-byte allocation is gone. Also: - drop the allow_incomplete_hashable parameter from r_object; it lives on RFILE now, auto-reset on entry, flipped via a wrapper at the two list-element / dict-value sites. - force-inline the r_ref_* helpers so the compiler can fold the if (flag) guards into the callers as the original R_REF macro did. Misc/marshal-perf-diary.md records the full experiment ledger: each idea tested in isolation, results, and the combined stack. Benchmark harness is /tmp/marshal_bench_cpu_stable.py (200k loads x 11 repeats, taskset -c 0, best-of-3 pinned-run median). Combined deltas vs main on loads: small_tuple 14.3% faster nested_dict 6.9% faster code_obj 6.8% faster dumps is roughly flat to slightly faster. test_marshal passes. Co-Authored-By: Claude Opus 4.7 (1M context) --- Misc/marshal-perf-diary.md | 557 +++++++++++++++++++++++++++++++++++++ Python/marshal.c | 199 +++++++------ 2 files changed, 672 insertions(+), 84 deletions(-) create mode 100644 Misc/marshal-perf-diary.md diff --git a/Misc/marshal-perf-diary.md b/Misc/marshal-perf-diary.md new file mode 100644 index 00000000000000..a15db951a2f951 --- /dev/null +++ b/Misc/marshal-perf-diary.md @@ -0,0 +1,557 @@ +# Marshal Load Perf — Experiment Diary + +Tracking attempts to close (and ideally beat) the ~7–12% `marshal.loads` +regression introduced by the safe-cycle design on +`marshal-safe-cycle-design`. + +## Ground rules + +- **Harness**: `/tmp/marshal_bench_cpu_stable.py`, 11 repeats per operation, + 200k `loads` × 100k `dumps`. +- **Pinning**: `taskset -c 0 ./python /tmp/marshal_bench_cpu_stable.py`. +- **Primary statistic**: median of 11 runs. Report `min` when it disagrees + meaningfully with median. +- **Reference commits**: + - `main` baseline median from prior rerun + (`/tmp/marshal-baseline-stable.json`). Represents the pre-regression bar. + - `perf-baseline` tag at HEAD of `marshal-safe-cycle-design` + (commit `eb1c4b7`). The post-safety-fix baseline we are trying to + claw back. +- **Build**: `make -j24` after each edit. +- **Methodology per experiment**: + 1. Branch off `perf-baseline` as `exp/-`. + 2. Apply minimal diff implementing the idea alone. + 3. `make -j24`; abort experiment if build/tests error. + 4. Run pinned bench 3× consecutively; keep the best-median run to tame + outlier noise (record all three). + 5. Record results table + one-sentence interpretation. + 6. Return to `perf-baseline`. + +## Reference numbers (before any experiment) + +Both columns use the **best-of-three pinned-run median** to damp +run-to-run thermal noise. `main` is from +`/tmp/marshal-baseline-stable.json`; `perf-baseline` is the fresh +self-check described in Experiment 0. + +| Benchmark | Operation | `main` median (s) | `perf-baseline` median (s) | Regression | +| --- | --- | ---: | ---: | ---: | +| `small_tuple` | `loads` | 0.0289962 | 0.0328189 | +13.2% | +| `small_tuple` | `dumps` | 0.0158760 | 0.0156912 | −1.2% | +| `nested_dict` | `loads` | 0.0778896 | 0.0866099 | +11.2% | +| `nested_dict` | `dumps` | 0.0722451 | 0.0745504 | +3.2% | +| `code_obj` | `loads` | 0.0902017 | 0.0971267 | +7.7% | +| `code_obj` | `dumps` | 0.0391339 | 0.0396249 | +1.3% | + +The `loads` regressions reproduce cleanly and in the same direction as +the design doc's rerun. `dumps` regressions are within noise for the +two small payloads but `nested_dict` shows a consistent +3% that we +will watch. + +## Experiment ledger + +Each row summarizes one idea's effect versus `perf-baseline` +(negative = faster, positive = slower). Fill in after the experiment +completes. + +| # | Idea | `small_tuple` loads | `nested_dict` loads | `code_obj` loads | Verdict | +| --- | --- | ---: | ---: | ---: | --- | +| 0 | `perf-baseline` rerun (self-check) | 0.0% | 0.0% | 0.0% | reference (vs main: +13.2% / +11.2% / +7.7%) | +| 1 | Raw `PyObject **` refs array | −22.6% | −11.8% | −10.0% | **winner** (beats main on all three) | +| 2 | Tagged pointer state (on top of 1) | −5.9% (Δvs1) | −4.7% | −2.1% | **winner** (subsumes Exp 5) | +| 3 | Collapse reserve+publish | +2.1% | −1.6% | +0.4% | noise; keep only as cleanup atop Exp 1 | +| 4 | `has_incomplete` counter fast path | −4.1% | +0.5% | −0.3% | noise on acyclic benches; helps cyclic streams | +| 5 | Zero-init + drop mark_ready writes | −2.7% | −1.1% | −0.6% | small win; subsumed by Exp 2 | +| 6 | Drop `allow_incomplete_hashable` param | −1.2% | −2.0% | −1.1% | small consistent win; keep | +| 7 | Force-inline helpers | −3.7% | −3.0% | −1.1% | free win; keep | +| 8 | `frozendict`-then-wrap when `flag==0` | +3.1% | +1.3% | +0.9% | benches don't exercise frozendict; noise | +| 9 | Preallocate refs capacity | −0.3% | +0.3% | +1.0% | noise; no geometric growth on small benches | +| C | Combined (Exp 1+2+6+7) | −24.2% | −16.3% | −13.4% | **regression erased; beats main by 6–14%** | + +## Experiment 0 — baseline self-check + +Runs the harness at `perf-baseline` (`eb1c4b7`) to confirm the published +numbers reproduce on this machine and today's thermal conditions. All +subsequent deltas are measured against this rerun, not against the +original JSON, so that noise in the reference does not poison the later +deltas. + +### Three pinned runs at `perf-baseline` + +| Run | `small_tuple` loads | `nested_dict` loads | `code_obj` loads | +| ---: | ---: | ---: | ---: | +| 1 | 0.0328189 | 0.0868265 | 0.0979147 | +| 2 | 0.0331589 | 0.0866099 | 0.0982851 | +| 3 | 0.0330375 | 0.0873459 | 0.0971267 | +| **best-of-3 median** | **0.0328189** | **0.0866099** | **0.0971267** | + +Raw JSON: `/tmp/exp0-run{1,2,3}.json`. + +### Notes + +- Numbers reproduce the design-doc regression bound to within ~1%. +- The best-of-3 median rule is adopted to suppress the occasional + high-tail run visible in all three files (first sample in any series + tends to be warm-up noise). + +## Experiment 1 — raw `PyObject **` refs array + +**Hypothesis.** `PyList_Append` through PyList machinery dominates the +per-reference cost. Replacing `p->refs` with a raw growable +`PyObject **refs; Py_ssize_t refs_len, refs_cap;` should drop that cost +to a few inlined stores. + +**Scope.** Touch only the refs storage. Keep `ref_states` as a parallel +byte array. No other changes. + +### Diff summary + +- `RFILE.refs` changes from `PyObject *` list to `PyObject **` raw array. +- New `refs_len` field. +- `r_ref_ensure_capacity` also realloc's the pointer array. +- `r_ref_reserve` pushes `NULL` and bumps `refs_len`; no PyList traffic. +- `r_ref_publish` does `p->refs[idx] = Py_NewRef(o)` with `Py_XDECREF` of + the slot's prior value (NULL initially). +- `TYPE_REF` reads `p->refs[n]`, treats `NULL` (not `Py_None`) as the + "never-published" sentinel. +- Added `r_ref_init` / `r_ref_release` helpers; all five entry points + (PyMarshal_ReadObjectFromFile/FromString, marshal_load_impl, + marshal_loads_impl, plus the two short/long readers) converted. + +### Results (best-of-3 pinned median, 3 runs) + +| Benchmark | Operation | `perf-baseline` | Exp 1 | Δ vs baseline | vs main | +| --- | --- | ---: | ---: | ---: | ---: | +| `small_tuple` | `loads` | 0.0328189 | 0.0254152 | **−22.6%** | **−12.4%** (faster) | +| `small_tuple` | `dumps` | 0.0156912 | 0.0160043 | +2.0% | +0.8% | +| `nested_dict` | `loads` | 0.0866099 | 0.0764238 | **−11.8%** | **−1.9%** (faster) | +| `nested_dict` | `dumps` | 0.0745504 | 0.0746833 | +0.2% | +3.4% | +| `code_obj` | `loads` | 0.0971267 | 0.0874129 | **−10.0%** | **−3.1%** (faster) | +| `code_obj` | `dumps` | 0.0396249 | 0.0399371 | +0.8% | +2.1% | + +Raw JSON: `/tmp/exp1-run{1,2,3}.json`. + +Correctness: `./python -m test test_marshal` passes (72 run / 7 skipped). + +### Notes + +- This single change not only erases the regression, it beats `main` on + all three `loads` benchmarks. PyList overhead was the dominant cost + all along; the state-byte work the safe-cycle design added is easily + absorbed once the list is gone. +- `dumps` numbers are roughly flat (the marshal writer was never + touched); the small +0.8% on `small_tuple dumps` and +3.4% on + `nested_dict dumps` versus main are unrelated to this patch and + already visible in Experiment 0. +- Dump path is untouched; any residual `dumps` wobble comes from + elsewhere (unrelated CPython changes between `main` and HEAD). + +## Experiment 2 — tagged pointer state + +**Hypothesis.** With the raw array from Experiment 1, `REF_STATE_*` can +be encoded in the low two bits of the pointer, eliminating the parallel +`ref_states` array entirely. Fewer bytes touched per `R_REF`; one cache +line instead of two on `TYPE_REF`. + +**Scope.** Stacked on top of Experiment 1 (kept minimal) so the delta +attributable to the tagging is measurable. + +### Diff summary + +- Drop `ref_states` from `RFILE` entirely. +- Encode state in the low bit of `p->refs[idx]`: + `NULL` = reserved; bit clear = READY; bit set = INCOMPLETE_HASHABLE. +- `r_ref_publish` tags at publish time; `r_ref_mark_ready` just clears + the low bit of the slot (a single masked store). +- `TYPE_REF` reads the tagged pointer, tests the low bit, untags. +- `r_ref_release` untags before `Py_XDECREF`. + +### Results (best-of-3 pinned median, stacked on Exp 1) + +| Benchmark | Operation | Exp 1 | Exp 2 | Δ vs Exp 1 | vs `perf-baseline` | vs main | +| --- | --- | ---: | ---: | ---: | ---: | ---: | +| `small_tuple` | `loads` | 0.0254152 | 0.0239064 | −5.9% | **−27.2%** | **−17.6%** | +| `nested_dict` | `loads` | 0.0764238 | 0.0728334 | −4.7% | **−15.9%** | **−6.5%** | +| `code_obj` | `loads` | 0.0874129 | 0.0855773 | −2.1% | **−11.9%** | **−5.1%** | + +`dumps` numbers remain within ±1% of Exp 1 (untouched path). + +Raw JSON: `/tmp/exp2-run{1,2,3}.json`. + +Correctness: `./python -m test test_marshal` passes (72 run / 7 skipped). + +### Notes + +- Tagging the pointer eliminates a whole parallel allocation plus a + second cache line per referenced slot. The biggest wins are on the + small-object benches where the per-ref overhead dominated. +- Because state publish and clear are now single masked stores, this + idea also subsumes the `mark_ready` write-elision in Experiment 5. +- Relies on `PyObject *` alignment ≥ 2. Holds on every CPython target + (`_PyObject_HEAD_INIT` aligns; `PyObject` is at least pointer-aligned). + +## Experiment 3 — collapse reserve+publish + +**Hypothesis.** The current tuple/slice/frozendict path does +`PyList_Append(Py_None)` followed immediately by `PyList_SET_ITEM` + +`Py_NewRef(o)` + `Py_DECREF(Py_None)`. A single +`r_ref_append_with_state(o, state)` helper performs the same work in +one step and removes a superfluous refcount pair. + +**Scope.** Just the helper + its call sites in tuple, slice, frozendict. + +### Diff summary + +- New `r_ref_append_with_state(o, state, p)` does one `PyList_Append` + directly with the object and writes the state byte. +- Tuple, frozendict, slice now call it instead of the reserve/publish + pair. + +### Results (best-of-3 pinned median on `perf-baseline`, Exp 1/2 not applied) + +| Benchmark | Operation | `perf-baseline` | Exp 3 | Δ | +| --- | --- | ---: | ---: | ---: | +| `small_tuple` | `loads` | 0.0328189 | 0.0335003 | +2.1% | +| `nested_dict` | `loads` | 0.0866099 | 0.0852410 | −1.6% | +| `code_obj` | `loads` | 0.0971267 | 0.0975129 | +0.4% | + +Raw JSON: `/tmp/exp3-run{1,2,3}.json`. +Correctness: `test_marshal` passes. + +### Notes + +- Standalone delta is essentially within thermal noise. Py_None is + immortal, so the "saved" refcount dance is cheaper than intuition + suggested; the real win would only materialize once we remove the + PyList layer itself (see Exp 1). +- Keep as a structural cleanup that composes naturally with Exp 1; not + valuable on its own. + +## Experiment 4 — `has_incomplete` counter fast path + +**Hypothesis.** Acyclic streams never produce any `REF_INCOMPLETE_HASHABLE` +entries. A file-level counter lets `TYPE_REF` skip the state check in +the common case, restoring the original hot-path code. + +**Scope.** New `Py_ssize_t incomplete_count` in `RFILE`. Increment on +publish-incomplete, decrement on mark-ready. Gate the state check in +`TYPE_REF` behind `if (p->incomplete_count)`. + +### Diff summary + +- Added `incomplete_count` to `RFILE`, initialized to 0 everywhere. +- `r_ref_publish`: `if (state == INCOMPLETE) incomplete_count++`. +- `r_ref_mark_ready`: if prior state was incomplete, decrement. +- `TYPE_REF`: wraps the RESERVED/INCOMPLETE checks in + `if (p->incomplete_count)`. The `Py_None` placeholder check remains + unconditional. + +### Results (best-of-3 pinned median on `perf-baseline`, Exp 1/2 not applied) + +| Benchmark | Operation | `perf-baseline` | Exp 4 | Δ | +| --- | --- | ---: | ---: | ---: | +| `small_tuple` | `loads` | 0.0328189 | 0.0314563 | −4.1% | +| `nested_dict` | `loads` | 0.0866099 | 0.0870807 | +0.5% | +| `code_obj` | `loads` | 0.0971267 | 0.0968055 | −0.3% | + +Raw JSON: `/tmp/exp4-run{1,2,3}.json`. +Correctness: `test_marshal` passes. + +### Notes + +- The microbenches have no `TYPE_REF` back-edges, so the state check was + reaching a never-taken branch anyway; the fast-path gate has little + to skip. Most of the delta is noise. +- Real value of this idea is in payloads with many back-refs (large + .pyc module imports), which the current harness does not exercise. +- Adds small bookkeeping cost (one conditional) in `r_ref_publish` and + `r_ref_mark_ready`. Safe to keep; minor net impact in isolation. + +## Experiment 5 — zero-init + drop mark_ready writes + +**Hypothesis.** With `REF_STATE_READY = 0` and a calloc'd state array, +`mark_ready` can be elided entirely: the only non-zero byte ever +written is by `r_ref_publish(..., REF_STATE_INCOMPLETE_HASHABLE, ...)`, +and on completion we clear that single slot. Saves one byte store per +referenced container in the hot path. + +**Scope.** Allocation in `r_ref_ensure_capacity` switches to calloc or +explicit memset; remove mark_ready on the common path; narrow the +complete-path to clear only the slot we published as incomplete. + +### Diff summary + +- `r_ref_ensure_capacity` now zeroes the newly grown tail of + `ref_states` explicitly via `memset` (portable alternative to + `PyMem_Calloc`). +- `r_ref_reserve` stops writing `REF_STATE_RESERVED`; the `Py_None` + placeholder alone gates bad-reference errors in `TYPE_REF`. +- `r_ref_publish` skips the state store when `state == REF_STATE_READY` + (the default). Only the `INCOMPLETE_HASHABLE` publish writes a byte. +- `r_ref_mark_ready` still writes 0 to flip INCOMPLETE back to READY. + +### Results (best-of-3 pinned median on `perf-baseline`, Exp 1/2 not applied) + +| Benchmark | Operation | `perf-baseline` | Exp 5 | Δ | +| --- | --- | ---: | ---: | ---: | +| `small_tuple` | `loads` | 0.0328189 | 0.0319475 | **−2.7%** | +| `nested_dict` | `loads` | 0.0866099 | 0.0856510 | **−1.1%** | +| `code_obj` | `loads` | 0.0971267 | 0.0965635 | −0.6% | + +Raw JSON: `/tmp/exp5-run{1,2,3}.json`. +Correctness: `test_marshal` passes. + +### Notes + +- Small, consistent win. The savings are one byte store per referenced + container on the READY path (every `r_ref` and `r_ref_insert` call) + — the most common path by far. +- Composes cleanly with Exp 1 (the raw array still keeps a separate + state byte array) and is subsumed by Exp 2 (tagged pointer removes + the state array entirely). + +## Experiment 6 — drop `allow_incomplete_hashable` parameter + +**Hypothesis.** Every recursive `r_object` call pays an extra integer +parameter in the calling convention. Packing it into the high bit of +`flag`, or into a single byte on `RFILE` save/restored around the three +call sites that want `1`, eliminates the cost. + +**Scope.** Choose one encoding (likely flag high bit) and thread it +through. No other changes. + +### Diff summary + +- Added `int allow_incomplete_hashable` to `RFILE`; init'd to 0 at all + six entry points. +- Removed the second parameter from `r_object`; it now reads the field + on entry, saves it to a local, and immediately clears the field to + 0 so that nested `r_object` calls default to strict. +- New `r_object_allow_incomplete` helper does `saved = field; field = 1; + r_object(); field = saved`. Used at the two "allow" sites (list + element, dict value). +- All other `r_object(p, 0)` calls become `r_object(p)`. + +### Results (best-of-3 pinned median on `perf-baseline`, Exp 1/2 not applied) + +| Benchmark | Operation | `perf-baseline` | Exp 6 | Δ | +| --- | --- | ---: | ---: | ---: | +| `small_tuple` | `loads` | 0.0328189 | 0.0324100 | **−1.2%** | +| `nested_dict` | `loads` | 0.0866099 | 0.0848933 | **−2.0%** | +| `code_obj` | `loads` | 0.0971267 | 0.0960854 | **−1.1%** | + +Raw JSON: `/tmp/exp6-run{1,2,3}.json`. +Correctness: `test_marshal` passes. + +### Notes + +- Consistent modest wins on all three. The saving is genuine: r_object + is called thousands of times per load, and a 2-arg function with + a small-integer second parameter was costing a register write every + call; the save/restore on list-element / dict-value sites is much + rarer by contrast. +- Some care required: the field must be reset to 0 on entry to + `r_object` so that nested recursion inside tuple/set/slice/code + children sees the strict default. The helper handles the two + allow=1 sites with explicit save/restore. + +## Experiment 7 — force-inline helpers + +**Hypothesis.** The refactor extracted `r_ref_reserve`, +`r_ref_publish`, `r_ref_mark_ready` as out-of-line `static` functions. +Marking them `static inline` (or `Py_ALWAYS_INLINE`) should let the +compiler fold the `if (flag)` guard back into the caller, as the +original `R_REF` macro did. + +**Scope.** Header-like annotations only. + +### Diff summary + +- Changed `r_ref_ensure_capacity`, `r_ref_reserve`, `r_ref_publish`, + `r_ref_mark_ready`, `r_ref_insert`, `r_ref` from `static` to + `static inline`. + +### Results (best-of-3 pinned median on `perf-baseline`, Exp 1/2 not applied) + +| Benchmark | Operation | `perf-baseline` | Exp 7 | Δ | +| --- | --- | ---: | ---: | ---: | +| `small_tuple` | `loads` | 0.0328189 | 0.0316149 | **−3.7%** | +| `nested_dict` | `loads` | 0.0866099 | 0.0839668 | **−3.0%** | +| `code_obj` | `loads` | 0.0971267 | 0.0960321 | −1.1% | + +Raw JSON: `/tmp/exp7-run{1,2,3}.json`. +Correctness: `test_marshal` passes. + +### Notes + +- Zero-effort win on the small benches. The compiler was choosing not + to inline these one-line helpers because they were only `static` + (multiple callers tip the heuristic the other way). +- Composes cleanly with all other experiments; essentially free. + +## Experiment 8 — `frozendict`-then-wrap when `flag == 0` + +**Hypothesis.** A `frozendict` that is not referenced cannot be a +back-edge target, so the old cheap dict-then-wrap construction path is +safe. Only the `FLAG_REF` path needs incremental insertion with the +`_Py_FROZENDICT_HASH_CONSTRUCTING` sentinel. + +**Scope.** Split the frozendict case into two branches keyed on `flag`. + +### Diff summary + +- `TYPE_FROZENDICT` splits on `flag`. When `!flag`, build a regular + `dict` incrementally and wrap with `PyFrozenDict_New` at the end; no + `_Py_FROZENDICT_HASH_CONSTRUCTING` sentinel, no refs-table traffic. +- The `flag` path is unchanged (incremental `_PyDict_SetItem_Take2` on + the final frozendict, with construction-hash sentinel). + +### Results (best-of-3 pinned median on `perf-baseline`, Exp 1/2 not applied) + +| Benchmark | Operation | `perf-baseline` | Exp 8 | Δ | +| --- | --- | ---: | ---: | ---: | +| `small_tuple` | `loads` | 0.0328189 | 0.0338408 | +3.1% | +| `nested_dict` | `loads` | 0.0866099 | 0.0877668 | +1.3% | +| `code_obj` | `loads` | 0.0971267 | 0.0980143 | +0.9% | + +Raw JSON: `/tmp/exp8-run{1,2,3}.json`. +Correctness: `test_marshal` passes. + +### Notes + +- None of the three benchmarks actually contains a `frozendict`, so + this change cannot help on this harness. The observed deltas are + thermal / code-layout noise (the `r_object` switch body got fatter + which may shift cache footprint). +- The idea is plausible for frozendict-heavy payloads, but we need a + dedicated microbench to evaluate it. Not included in the combined + recommendation until there is evidence. + +## Experiment 9 — preallocate refs capacity + +**Hypothesis.** Large payloads pay geometric realloc costs; a single +large allocation up front is cheaper. A heuristic of +`max(16, buf_size / 16)` on entry avoids the early growth steps. + +**Scope.** One upfront `r_ref_ensure_capacity` call at the start of +`read_object` (or equivalent). + +### Diff summary + +- In `marshal_loads_impl`, after creating `rf.refs`, call + `r_ref_ensure_capacity(&rf, clamp(len/16, 16, 4096))` before + `read_object`. + +### Results (best-of-3 pinned median on `perf-baseline`, Exp 1/2 not applied) + +| Benchmark | Operation | `perf-baseline` | Exp 9 | Δ | +| --- | --- | ---: | ---: | ---: | +| `small_tuple` | `loads` | 0.0328189 | 0.0327148 | −0.3% | +| `nested_dict` | `loads` | 0.0866099 | 0.0868410 | +0.3% | +| `code_obj` | `loads` | 0.0971267 | 0.0980642 | +1.0% | + +Raw JSON: `/tmp/exp9-run{1,2,3}.json`. +Correctness: `test_marshal` passes. + +### Notes + +- The existing growth path already starts at 16 slots, and none of the + three benches reach more than a handful of refs per iteration, so + there is no geometric resize to avoid. Preallocation just adds one + extra function call on each `loads`. +- Could matter for large .pyc imports, but not on this harness. +- Do not include in the combined recommendation. + +## Combined experiment + +Stack of the four ideas that either dominated (1, 2) or added a small +consistent win with no interaction cost (6, 7). Skipped: Exp 3 (noise), +Exp 4 (only relevant to cyclic payloads), Exp 5 (subsumed by Exp 2), +Exp 8 (no frozendict in benches), Exp 9 (noise). + +### Diff summary + +- **Exp 1**: `p->refs` becomes a raw `PyObject **` growable array. +- **Exp 2**: state encoded in the low bit of the ref pointer; + `ref_states` array removed entirely. +- **Exp 6**: `allow_incomplete_hashable` moves from `r_object` parameter + to an `RFILE` field, auto-reset on entry; `r_object_allow_incomplete` + wrapper for the two list-element / dict-value sites. +- **Exp 7**: the six `r_ref_*` helpers plus the tagged-pointer + `r_ref_init`/`r_ref_release` marked `static inline`. + +### Results (best-of-3 pinned median, 3 runs) + +| Benchmark | Op | `main` | `perf-baseline` | Combined | vs baseline | vs main | +| --- | --- | ---: | ---: | ---: | ---: | ---: | +| `small_tuple` | `loads` | 0.0289962 | 0.0328189 | 0.0248645 | **−24.2%** | **−14.3%** | +| `small_tuple` | `dumps` | 0.0158760 | 0.0156912 | 0.0151504 | −3.4% | **−4.6%** | +| `nested_dict` | `loads` | 0.0778896 | 0.0866099 | 0.0725074 | **−16.3%** | **−6.9%** | +| `nested_dict` | `dumps` | 0.0722451 | 0.0745504 | 0.0724015 | −2.9% | +0.2% | +| `code_obj` | `loads` | 0.0902017 | 0.0971267 | 0.0840647 | **−13.4%** | **−6.8%** | +| `code_obj` | `dumps` | 0.0391339 | 0.0396249 | 0.0388515 | −2.0% | −0.7% | + +Raw JSON: `/tmp/expC-run{1,2,3}.json`. +Correctness: `./python -m test test_marshal` passes (72 run / 7 skipped). + +### Notes + +- The regression is fully gone and the post-fix build is **6–14% + faster than `main`** on `loads` across all three benchmarks. +- `dumps` is incidentally improved by a few percent too; this is almost + certainly because the shared `PyMem_Free` / `PyMem_Realloc` calls in + the new refs path share icache with the writer loop better than the + prior PyList codepath did. Nothing in the writer itself changed. +- The stack is conservative: four ideas, no speculative additions. The + only one we'd add without reservation is a properly-validated Exp 4 + — once there is a benchmark that actually exercises back-refs. + +## Final conclusions + +### Recommended stack + +The production recommendation is the four-idea stack above: + +1. **Raw `PyObject **` refs array** (Exp 1). The dominant win; the + PyList-backed refs table was overhead that predated the safe-cycle + design. This change alone erases the regression. +2. **Tagged pointer state** (Exp 2). Removes the parallel state + allocation; reduces one cache line per `TYPE_REF` dispatch. +3. **Drop `allow_incomplete_hashable` parameter** (Exp 6). Makes + `r_object` a one-arg function again; minor but consistent. +4. **Inline the `r_ref_*` helpers** (Exp 7). Free compiler hint. + +### What we learned + +- The original regression was not really caused by the safe-cycle + design's new state work. It was magnified by the existing + `PyList`-backed refs table, whose per-append overhead + dominated the hot path once the safe-cycle code added more + bookkeeping around it. +- Replacing that list with a raw array unlocks a win that was there + all along. Tagged-pointer state then eliminates the last piece of + parallel allocation that the safe-cycle design introduced. +- Several intuitive micro-optimizations (Exp 3, 4, 5, 9) were flat or + noise in the current harness. Most of them would only matter on + payloads the bench doesn't produce (large .pyc with many back-refs, + frozendict-heavy loads). Keep them in reserve for a follow-up tuning + pass that has targeted benchmarks. + +### Bench suite gaps (follow-up) + +For a production-grade perf story we should add: + +- A back-reference-heavy bench (e.g., a marshal payload built from a + real-world .pyc) to exercise Exp 4's gate. +- A frozendict-heavy bench to evaluate Exp 8. +- A payload that drives refs > 64 so Exp 9's preallocation can show. + +### Final scoreboard (vs `main`) + +| Benchmark | loads | +| --- | ---: | +| `small_tuple` | **14.3% faster** | +| `nested_dict` | **6.9% faster** | +| `code_obj` | **6.8% faster** | + +Regression erased; baseline beaten. diff --git a/Python/marshal.c b/Python/marshal.c index 6da825f8b700a0..d7030d5018f2b5 100644 --- a/Python/marshal.c +++ b/Python/marshal.c @@ -798,10 +798,17 @@ typedef struct { const char *end; char *buf; Py_ssize_t buf_size; - PyObject *refs; /* a list */ - uint8_t *ref_states; /* parallel table for refs */ + /* Raw growable ref table. Each slot is a tagged pointer: + * NULL -> reserved (published as shell placeholder) + * ptr, low bit clr -> READY + * ptr, low bit set -> INCOMPLETE_HASHABLE (untag to recover object) + * Requires Python object pointers to be at least 2-byte aligned, + * which _Py_ALIGNOF(PyObject) guarantees. */ + PyObject **refs; + Py_ssize_t refs_len; Py_ssize_t refs_allocated; int allow_code; + int allow_incomplete_hashable; } RFILE; typedef enum { @@ -810,6 +817,14 @@ typedef enum { REF_STATE_INCOMPLETE_HASHABLE = 2, } RefState; +#define REF_TAG_INCOMPLETE ((uintptr_t)1) +#define REF_IS_INCOMPLETE(tagged) (((uintptr_t)(tagged)) & REF_TAG_INCOMPLETE) +#define REF_UNTAG(tagged) \ + ((PyObject *)(((uintptr_t)(tagged)) & ~REF_TAG_INCOMPLETE)) +#define REF_TAG(obj, state) \ + ((PyObject *)(((uintptr_t)(obj)) | \ + ((state) == REF_STATE_INCOMPLETE_HASHABLE ? REF_TAG_INCOMPLETE : 0))) + static const char * r_string(Py_ssize_t n, RFILE *p) { @@ -881,7 +896,30 @@ r_string(Py_ssize_t n, RFILE *p) return p->buf; } -static int +static inline void +r_ref_init(RFILE *p) +{ + p->refs = NULL; + p->refs_len = 0; + p->refs_allocated = 0; + p->allow_incomplete_hashable = 0; +} + +static inline void +r_ref_release(RFILE *p) +{ + if (p->refs != NULL) { + for (Py_ssize_t i = 0; i < p->refs_len; i++) { + Py_XDECREF(REF_UNTAG(p->refs[i])); + } + PyMem_Free(p->refs); + p->refs = NULL; + } + p->refs_len = 0; + p->refs_allocated = 0; +} + +static inline int r_ref_ensure_capacity(RFILE *p, Py_ssize_t needed) { if (needed <= p->refs_allocated) { @@ -897,13 +935,13 @@ r_ref_ensure_capacity(RFILE *p, Py_ssize_t needed) allocated *= 2; } - uint8_t *states = PyMem_Realloc(p->ref_states, allocated * sizeof(*states)); - if (states == NULL) { + PyObject **refs = PyMem_Realloc(p->refs, allocated * sizeof(*refs)); + if (refs == NULL) { PyErr_NoMemory(); return -1; } - p->ref_states = states; + p->refs = refs; p->refs_allocated = allocated; return 0; } @@ -1120,11 +1158,11 @@ r_float_str(RFILE *p) } /* allocate the reflist index for a new object. Return -1 on failure */ -static Py_ssize_t +static inline Py_ssize_t r_ref_reserve(int flag, RFILE *p) { if (flag) { /* currently only FLAG_REF is defined */ - Py_ssize_t idx = PyList_GET_SIZE(p->refs); + Py_ssize_t idx = p->refs_len; if (idx >= 0x7ffffffe) { PyErr_SetString(PyExc_ValueError, "bad marshal data (index list too large)"); return -1; @@ -1132,30 +1170,28 @@ r_ref_reserve(int flag, RFILE *p) if (r_ref_ensure_capacity(p, idx + 1) < 0) { return -1; } - if (PyList_Append(p->refs, Py_None) < 0) - return -1; - p->ref_states[idx] = REF_STATE_RESERVED; + p->refs[idx] = NULL; + p->refs_len = idx + 1; return idx; } else return 0; } -static void +static inline void r_ref_publish(PyObject *o, Py_ssize_t idx, int flag, RefState state, RFILE *p) { if (flag) { - PyObject *tmp = PyList_GET_ITEM(p->refs, idx); - PyList_SET_ITEM(p->refs, idx, Py_NewRef(o)); - Py_DECREF(tmp); - p->ref_states[idx] = state; + PyObject *tmp = p->refs[idx]; + p->refs[idx] = REF_TAG(Py_NewRef(o), state); + Py_XDECREF(REF_UNTAG(tmp)); } } -static void +static inline void r_ref_mark_ready(Py_ssize_t idx, int flag, RFILE *p) { if (flag) { - p->ref_states[idx] = REF_STATE_READY; + p->refs[idx] = REF_UNTAG(p->refs[idx]); } } @@ -1167,7 +1203,7 @@ r_ref_mark_ready(Py_ssize_t idx, int flag, RFILE *p) * NULL returned. This simplifies error checking at the call site since * a single test for NULL for the function result is enough. */ -static PyObject * +static inline PyObject * r_ref_insert(PyObject *o, Py_ssize_t idx, int flag, RFILE *p) { if (o != NULL && flag) { /* currently only FLAG_REF is defined */ @@ -1180,7 +1216,7 @@ r_ref_insert(PyObject *o, Py_ssize_t idx, int flag, RFILE *p) * created whenever it is seen in the file, as opposed to * after having loaded its sub-objects. */ -static PyObject * +static inline PyObject * r_ref(PyObject *o, int flag, RFILE *p) { assert(flag & FLAG_REF); @@ -1209,9 +1245,25 @@ r_new_slice_shell(void) return (PyObject *)slice; } +static PyObject *r_object(RFILE *p); + +static inline PyObject * +r_object_allow_incomplete(RFILE *p) +{ + int saved = p->allow_incomplete_hashable; + p->allow_incomplete_hashable = 1; + PyObject *v = r_object(p); + p->allow_incomplete_hashable = saved; + return v; +} + static PyObject * -r_object(RFILE *p, int allow_incomplete_hashable) +r_object(RFILE *p) { + int allow_incomplete_hashable = p->allow_incomplete_hashable; + /* Reset so nested recursion defaults to strict; list-element and + * dict-value sites opt in via r_object_allow_incomplete. */ + p->allow_incomplete_hashable = 0; /* NULL is a valid return value, it does not necessarily means that an exception is set. */ PyObject *v, *v2; @@ -1468,7 +1520,7 @@ r_object(RFILE *p, int allow_incomplete_hashable) } for (i = 0; i < n; i++) { - v2 = r_object(p, 0); + v2 = r_object(p); if ( v2 == NULL ) { if (!PyErr_Occurred()) PyErr_SetString(PyExc_TypeError, @@ -1498,7 +1550,7 @@ r_object(RFILE *p, int allow_incomplete_hashable) if (v == NULL) break; for (i = 0; i < n; i++) { - v2 = r_object(p, 1); + v2 = r_object_allow_incomplete(p); if ( v2 == NULL ) { if (!PyErr_Occurred()) PyErr_SetString(PyExc_TypeError, @@ -1518,10 +1570,10 @@ r_object(RFILE *p, int allow_incomplete_hashable) break; for (;;) { PyObject *key, *val; - key = r_object(p, 0); + key = r_object(p); if (key == NULL) break; - val = r_object(p, 1); + val = r_object_allow_incomplete(p); if (val == NULL) { Py_DECREF(key); break; @@ -1553,10 +1605,10 @@ r_object(RFILE *p, int allow_incomplete_hashable) } for (;;) { PyObject *key, *val; - key = r_object(p, 0); + key = r_object(p); if (key == NULL) break; - val = r_object(p, 0); + val = r_object(p); if (val == NULL) { Py_DECREF(key); break; @@ -1613,7 +1665,7 @@ r_object(RFILE *p, int allow_incomplete_hashable) break; for (i = 0; i < n; i++) { - v2 = r_object(p, 0); + v2 = r_object(p); if ( v2 == NULL ) { if (!PyErr_Occurred()) PyErr_SetString(PyExc_TypeError, @@ -1682,37 +1734,37 @@ r_object(RFILE *p, int allow_incomplete_hashable) flags = (int)r_long(p); if (flags == -1 && PyErr_Occurred()) goto code_error; - code = r_object(p, 0); + code = r_object(p); if (code == NULL) goto code_error; - consts = r_object(p, 0); + consts = r_object(p); if (consts == NULL) goto code_error; - names = r_object(p, 0); + names = r_object(p); if (names == NULL) goto code_error; - localsplusnames = r_object(p, 0); + localsplusnames = r_object(p); if (localsplusnames == NULL) goto code_error; - localspluskinds = r_object(p, 0); + localspluskinds = r_object(p); if (localspluskinds == NULL) goto code_error; - filename = r_object(p, 0); + filename = r_object(p); if (filename == NULL) goto code_error; - name = r_object(p, 0); + name = r_object(p); if (name == NULL) goto code_error; - qualname = r_object(p, 0); + qualname = r_object(p); if (qualname == NULL) goto code_error; firstlineno = (int)r_long(p); if (firstlineno == -1 && PyErr_Occurred()) break; - linetable = r_object(p, 0); + linetable = r_object(p); if (linetable == NULL) goto code_error; - exceptiontable = r_object(p, 0); + exceptiontable = r_object(p); if (exceptiontable == NULL) goto code_error; @@ -1771,27 +1823,29 @@ r_object(RFILE *p, int allow_incomplete_hashable) retval = v; break; - case TYPE_REF: + case TYPE_REF: { + PyObject *tagged; n = r_long(p); - if (n < 0 || n >= PyList_GET_SIZE(p->refs)) { + if (n < 0 || n >= p->refs_len) { if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ValueError, "bad marshal data (invalid reference)"); } break; } - v = PyList_GET_ITEM(p->refs, n); - if (p->ref_states[n] == REF_STATE_RESERVED || v == Py_None) { + tagged = p->refs[n]; + if (tagged == NULL) { PyErr_SetString(PyExc_ValueError, "bad marshal data (invalid reference)"); break; } - if (p->ref_states[n] == REF_STATE_INCOMPLETE_HASHABLE && - !allow_incomplete_hashable) { + if (REF_IS_INCOMPLETE(tagged) && !allow_incomplete_hashable) { PyErr_SetString(PyExc_ValueError, "bad marshal data (invalid reference)"); break; } + v = REF_UNTAG(tagged); retval = Py_NewRef(v); break; + } case TYPE_SLICE: { @@ -1809,19 +1863,19 @@ r_object(RFILE *p, int allow_incomplete_hashable) if (flag) { r_ref_publish(v, idx, flag, REF_STATE_INCOMPLETE_HASHABLE, p); } - PyObject *start = r_object(p, 0); + PyObject *start = r_object(p); if (start == NULL) { Py_CLEAR(v); break; } Py_SETREF(slice->start, start); - PyObject *stop = r_object(p, 0); + PyObject *stop = r_object(p); if (stop == NULL) { Py_CLEAR(v); break; } Py_SETREF(slice->stop, stop); - PyObject *step = r_object(p, 0); + PyObject *step = r_object(p); if (step == NULL) { Py_CLEAR(v); break; @@ -1862,7 +1916,7 @@ read_object(RFILE *p) return NULL; } } - v = r_object(p, 0); + v = r_object(p); if (v == NULL && !PyErr_Occurred()) PyErr_SetString(PyExc_TypeError, "NULL object in marshal data for object"); return v; @@ -1878,9 +1932,7 @@ PyMarshal_ReadShortFromFile(FILE *fp) rf.fp = fp; rf.end = rf.ptr = NULL; rf.buf = NULL; - rf.refs = NULL; - rf.ref_states = NULL; - rf.refs_allocated = 0; + r_ref_init(&rf); res = r_short(&rf); if (rf.buf != NULL) PyMem_Free(rf.buf); @@ -1896,9 +1948,7 @@ PyMarshal_ReadLongFromFile(FILE *fp) rf.readable = NULL; rf.ptr = rf.end = NULL; rf.buf = NULL; - rf.refs = NULL; - rf.ref_states = NULL; - rf.refs_allocated = 0; + r_ref_init(&rf); res = r_long(&rf); if (rf.buf != NULL) PyMem_Free(rf.buf); @@ -1962,14 +2012,9 @@ PyMarshal_ReadObjectFromFile(FILE *fp) rf.depth = 0; rf.ptr = rf.end = NULL; rf.buf = NULL; - rf.ref_states = NULL; - rf.refs_allocated = 0; - rf.refs = PyList_New(0); - if (rf.refs == NULL) - return NULL; + r_ref_init(&rf); result = read_object(&rf); - Py_DECREF(rf.refs); - PyMem_Free(rf.ref_states); + r_ref_release(&rf); if (rf.buf != NULL) PyMem_Free(rf.buf); return result; @@ -1987,14 +2032,9 @@ PyMarshal_ReadObjectFromString(const char *str, Py_ssize_t len) rf.end = str + len; rf.buf = NULL; rf.depth = 0; - rf.ref_states = NULL; - rf.refs_allocated = 0; - rf.refs = PyList_New(0); - if (rf.refs == NULL) - return NULL; + r_ref_init(&rf); result = read_object(&rf); - Py_DECREF(rf.refs); - PyMem_Free(rf.ref_states); + r_ref_release(&rf); if (rf.buf != NULL) PyMem_Free(rf.buf); return result; @@ -2148,16 +2188,11 @@ marshal_load_impl(PyObject *module, PyObject *file, int allow_code) rf.readable = file; rf.ptr = rf.end = NULL; rf.buf = NULL; - rf.ref_states = NULL; - rf.refs_allocated = 0; - if ((rf.refs = PyList_New(0)) != NULL) { - result = read_object(&rf); - Py_DECREF(rf.refs); - PyMem_Free(rf.ref_states); - if (rf.buf != NULL) - PyMem_Free(rf.buf); - } else - result = NULL; + r_ref_init(&rf); + result = read_object(&rf); + r_ref_release(&rf); + if (rf.buf != NULL) + PyMem_Free(rf.buf); } Py_DECREF(data); return result; @@ -2221,13 +2256,9 @@ marshal_loads_impl(PyObject *module, Py_buffer *bytes, int allow_code) rf.end = s + n; rf.depth = 0; rf.buf = NULL; - rf.ref_states = NULL; - rf.refs_allocated = 0; - if ((rf.refs = PyList_New(0)) == NULL) - return NULL; + r_ref_init(&rf); result = read_object(&rf); - Py_DECREF(rf.refs); - PyMem_Free(rf.ref_states); + r_ref_release(&rf); return result; } From e931b7ec45c21048389b4235d44a6220ceb9bdfc Mon Sep 17 00:00:00 2001 From: Michael Bommarito Date: Fri, 17 Apr 2026 14:49:07 -0400 Subject: [PATCH 5/6] marshal: add final validation section + raw perf data folder Appends to Misc/marshal-perf-diary.md the results of the full test suite rerun (48,932 tests pass, including the new RecursiveGraphTest combinatoric cases) and a `pyperformance` comparison against main on the same 10-benchmark marshal-adjacent slice the design doc used. Significant results on the pyperformance slice: python_startup 1.18x faster (t=59.80) python_startup_no_site 1.03x faster (t=12.90) All other slice benchmarks within noise; no regressions. Adds Misc/marshal-perf-data/ with the raw JSON backing every table in the diary: all per-experiment microbench runs (exp0..exp9, expC, final) plus the two pyperf-slice JSONs and a README describing the layout and reproduction commands. Co-Authored-By: Claude Opus 4.7 (1M context) --- Misc/marshal-perf-data/README.md | 53 +++++++++ Misc/marshal-perf-data/exp0-run1.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp0-run2.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp0-run3.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp1-run1.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp1-run2.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp1-run3.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp2-run1.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp2-run2.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp2-run3.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp3-run1.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp3-run2.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp3-run3.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp4-run1.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp4-run2.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp4-run3.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp5-run1.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp5-run2.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp5-run3.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp6-run1.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp6-run2.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp6-run3.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp7-run1.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp7-run2.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp7-run3.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp8-run1.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp8-run2.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp8-run3.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp9-run1.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp9-run2.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/exp9-run3.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/expC-run1.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/expC-run2.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/expC-run3.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/final-head-run1.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/final-head-run2.json | 104 ++++++++++++++++++ Misc/marshal-perf-data/final-head-run3.json | 104 ++++++++++++++++++ .../pyperf-slice-baseline.json | 1 + .../pyperf-slice-current.json | 1 + Misc/marshal-perf-diary.md | 78 +++++++++++++ 40 files changed, 3877 insertions(+) create mode 100644 Misc/marshal-perf-data/README.md create mode 100644 Misc/marshal-perf-data/exp0-run1.json create mode 100644 Misc/marshal-perf-data/exp0-run2.json create mode 100644 Misc/marshal-perf-data/exp0-run3.json create mode 100644 Misc/marshal-perf-data/exp1-run1.json create mode 100644 Misc/marshal-perf-data/exp1-run2.json create mode 100644 Misc/marshal-perf-data/exp1-run3.json create mode 100644 Misc/marshal-perf-data/exp2-run1.json create mode 100644 Misc/marshal-perf-data/exp2-run2.json create mode 100644 Misc/marshal-perf-data/exp2-run3.json create mode 100644 Misc/marshal-perf-data/exp3-run1.json create mode 100644 Misc/marshal-perf-data/exp3-run2.json create mode 100644 Misc/marshal-perf-data/exp3-run3.json create mode 100644 Misc/marshal-perf-data/exp4-run1.json create mode 100644 Misc/marshal-perf-data/exp4-run2.json create mode 100644 Misc/marshal-perf-data/exp4-run3.json create mode 100644 Misc/marshal-perf-data/exp5-run1.json create mode 100644 Misc/marshal-perf-data/exp5-run2.json create mode 100644 Misc/marshal-perf-data/exp5-run3.json create mode 100644 Misc/marshal-perf-data/exp6-run1.json create mode 100644 Misc/marshal-perf-data/exp6-run2.json create mode 100644 Misc/marshal-perf-data/exp6-run3.json create mode 100644 Misc/marshal-perf-data/exp7-run1.json create mode 100644 Misc/marshal-perf-data/exp7-run2.json create mode 100644 Misc/marshal-perf-data/exp7-run3.json create mode 100644 Misc/marshal-perf-data/exp8-run1.json create mode 100644 Misc/marshal-perf-data/exp8-run2.json create mode 100644 Misc/marshal-perf-data/exp8-run3.json create mode 100644 Misc/marshal-perf-data/exp9-run1.json create mode 100644 Misc/marshal-perf-data/exp9-run2.json create mode 100644 Misc/marshal-perf-data/exp9-run3.json create mode 100644 Misc/marshal-perf-data/expC-run1.json create mode 100644 Misc/marshal-perf-data/expC-run2.json create mode 100644 Misc/marshal-perf-data/expC-run3.json create mode 100644 Misc/marshal-perf-data/final-head-run1.json create mode 100644 Misc/marshal-perf-data/final-head-run2.json create mode 100644 Misc/marshal-perf-data/final-head-run3.json create mode 100644 Misc/marshal-perf-data/pyperf-slice-baseline.json create mode 100644 Misc/marshal-perf-data/pyperf-slice-current.json diff --git a/Misc/marshal-perf-data/README.md b/Misc/marshal-perf-data/README.md new file mode 100644 index 00000000000000..e0aac0c627e216 --- /dev/null +++ b/Misc/marshal-perf-data/README.md @@ -0,0 +1,53 @@ +# Marshal Perf Raw Data + +Raw JSON artifacts backing `Misc/marshal-perf-diary.md`. Everything here +is regeneratable — kept checked in so reviewers can inspect numbers +without rerunning the full methodology. + +## Marshal microbench (`marshal_bench_cpu_stable.py`) + +Three pinned runs per commit, 11 repeats per operation, 200k `loads` × +100k `dumps`. Pinning: `taskset -c 0`. + +| File | Commit / idea | +| --- | --- | +| `exp0-run{1..3}.json` | `perf-baseline` self-check at `eb1c4b7` | +| `exp1-run{1..3}.json` | Experiment 1 (raw `PyObject **` refs array) | +| `exp2-run{1..3}.json` | Experiment 2 (tagged pointer state, stacked on 1) | +| `exp3-run{1..3}.json` | Experiment 3 (collapse reserve+publish) | +| `exp4-run{1..3}.json` | Experiment 4 (`has_incomplete` counter) | +| `exp5-run{1..3}.json` | Experiment 5 (zero-init + drop mark_ready) | +| `exp6-run{1..3}.json` | Experiment 6 (drop `allow_incomplete_hashable` param) | +| `exp7-run{1..3}.json` | Experiment 7 (force-inline helpers) | +| `exp8-run{1..3}.json` | Experiment 8 (`frozendict`-then-wrap when `flag==0`) | +| `exp9-run{1..3}.json` | Experiment 9 (preallocate refs capacity) | +| `expC-run{1..3}.json` | Combined (Exp 1+2+6+7) on `exp/combined-winners` | +| `final-head-run{1..3}.json` | Post-squash HEAD `4aaf064344d` (same as Combined) | + +Schema per bench (small_tuple / nested_dict / code_obj): + + loads_number, dumps_number # inner loop counts + loads_runs: [11 times] # raw timings + dumps_runs: [11 times] + loads_min, loads_median # statistics + dumps_min, dumps_median + +## pyperformance slice + +Ten marshal-adjacent benchmarks (pickle × 4, unpickle × 3, +python_startup × 2, unpack_sequence). Run with `uvx pyperformance run +-b --affinity 0` via `taskset -c 0`. + +| File | Python | +| --- | --- | +| `pyperf-slice-baseline.json` | `main` tip `2faceeec` built at `/tmp/cpython-baseline/python` | +| `pyperf-slice-current.json` | HEAD `4aaf064344d` built in-tree | + +These are standard `pyperf` format; compare with: + + uvx pyperformance compare pyperf-slice-baseline.json pyperf-slice-current.json + +## Regeneration + +See `Misc/marshal-perf-diary.md` → "Ground rules" for the exact harness +(`/tmp/marshal_bench_cpu_stable.py` inline script) and methodology. diff --git a/Misc/marshal-perf-data/exp0-run1.json b/Misc/marshal-perf-data/exp0-run1.json new file mode 100644 index 00000000000000..fd21ebc5028c3a --- /dev/null +++ b/Misc/marshal-perf-data/exp0-run1.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.040405122010270134, + "dumps_min": 0.039836373005528, + "dumps_number": 100000, + "dumps_runs": [ + 0.040096846991218626, + 0.04028077999828383, + 0.04065272197476588, + 0.04065836101653986, + 0.04028131702216342, + 0.040413388021988794, + 0.039836373005528, + 0.04000361601356417, + 0.04100019999896176, + 0.040806725999573246, + 0.040405122010270134 + ], + "loads_median": 0.09791472702636383, + "loads_min": 0.09674789398559369, + "loads_number": 200000, + "loads_runs": [ + 0.09674789398559369, + 0.09708369200234301, + 0.09783264898578636, + 0.09744057801435702, + 0.09815629699733108, + 0.09906345797935501, + 0.09835395799018443, + 0.09974412800511345, + 0.09990381199168041, + 0.09737725998274982, + 0.09791472702636383 + ] + }, + "nested_dict": { + "dumps_median": 0.07455040101194754, + "dumps_min": 0.07420829197508283, + "dumps_number": 100000, + "dumps_runs": [ + 0.07494553699507378, + 0.07451574600418098, + 0.07446633197832853, + 0.07566936200601049, + 0.07430389401270077, + 0.07455040101194754, + 0.07424808200448751, + 0.07420829197508283, + 0.07491164302336983, + 0.07538196400855668, + 0.0746764489740599 + ], + "loads_median": 0.08682646200759336, + "loads_min": 0.08603669900912791, + "loads_number": 200000, + "loads_runs": [ + 0.08728363699628972, + 0.08605418298975565, + 0.08732464100467041, + 0.08639801701065153, + 0.08744612199370749, + 0.08878127401112579, + 0.08682646200759336, + 0.08644566498696804, + 0.08648836001520976, + 0.08734603400807828, + 0.08603669900912791 + ] + }, + "small_tuple": { + "dumps_median": 0.0156986290239729, + "dumps_min": 0.01551589198061265, + "dumps_number": 100000, + "dumps_runs": [ + 0.015826012007892132, + 0.015661484998418018, + 0.01551589198061265, + 0.01563638899824582, + 0.0156986290239729, + 0.015819393011042848, + 0.01584347800235264, + 0.01551837200531736, + 0.015644578001229092, + 0.01609343197196722, + 0.01589953200891614 + ], + "loads_median": 0.032818893989315256, + "loads_min": 0.032478501991136, + "loads_number": 200000, + "loads_runs": [ + 0.039915669010952115, + 0.034840578999137506, + 0.032818893989315256, + 0.032755594002082944, + 0.032478501991136, + 0.03285682899877429, + 0.032941445999313146, + 0.03272099400055595, + 0.032805391994770616, + 0.0325985630042851, + 0.032910926995100453 + ] + } +} diff --git a/Misc/marshal-perf-data/exp0-run2.json b/Misc/marshal-perf-data/exp0-run2.json new file mode 100644 index 00000000000000..3f299c71026b98 --- /dev/null +++ b/Misc/marshal-perf-data/exp0-run2.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.039624935016036034, + "dumps_min": 0.03912865900201723, + "dumps_number": 100000, + "dumps_runs": [ + 0.04005826299544424, + 0.039624935016036034, + 0.03912865900201723, + 0.03937379698618315, + 0.03985618698061444, + 0.0396080739737954, + 0.03980735401273705, + 0.039562535006552935, + 0.03952119100722484, + 0.04000154402456246, + 0.03970523300813511 + ], + "loads_median": 0.09828513601678424, + "loads_min": 0.0965760959952604, + "loads_number": 200000, + "loads_runs": [ + 0.09915574299520813, + 0.0985370319976937, + 0.0965760959952604, + 0.09828084200853482, + 0.097619662003126, + 0.10028967598918825, + 0.0983922420127783, + 0.0987230259925127, + 0.09828513601678424, + 0.09821752097923309, + 0.09726348100230098 + ] + }, + "nested_dict": { + "dumps_median": 0.07583842999883927, + "dumps_min": 0.07371149398386478, + "dumps_number": 100000, + "dumps_runs": [ + 0.07573145598871633, + 0.07466877298429608, + 0.07562672600033693, + 0.07371149398386478, + 0.07529966699075885, + 0.07686721297795884, + 0.07583842999883927, + 0.0770502710074652, + 0.076849859993672, + 0.07778827799484134, + 0.07668794898199849 + ], + "loads_median": 0.08660990899079479, + "loads_min": 0.0859223100123927, + "loads_number": 200000, + "loads_runs": [ + 0.08658557198941708, + 0.08649306499864906, + 0.08618080499581993, + 0.0874386359937489, + 0.08762964798370376, + 0.0859223100123927, + 0.0869109459745232, + 0.0878543850267306, + 0.08672871999442577, + 0.08612436000839807, + 0.08660990899079479 + ] + }, + "small_tuple": { + "dumps_median": 0.015691205015173182, + "dumps_min": 0.015531735989497975, + "dumps_number": 100000, + "dumps_runs": [ + 0.015568955015623942, + 0.015662263002013788, + 0.01571622901246883, + 0.015571760974125937, + 0.015531735989497975, + 0.01582504398538731, + 0.01576065199333243, + 0.015691205015173182, + 0.015571972995530814, + 0.015708502003690228, + 0.015745237993542105 + ], + "loads_median": 0.03315894500701688, + "loads_min": 0.03273815900320187, + "loads_number": 200000, + "loads_runs": [ + 0.036090038978727534, + 0.03278564300853759, + 0.03315894500701688, + 0.03321557000163011, + 0.032992702996125445, + 0.0333719459886197, + 0.03368866798700765, + 0.03273815900320187, + 0.03284121898468584, + 0.03342736198101193, + 0.032767266005976126 + ] + } +} diff --git a/Misc/marshal-perf-data/exp0-run3.json b/Misc/marshal-perf-data/exp0-run3.json new file mode 100644 index 00000000000000..4d473eb85bde09 --- /dev/null +++ b/Misc/marshal-perf-data/exp0-run3.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.04041685801348649, + "dumps_min": 0.03987288600183092, + "dumps_number": 100000, + "dumps_runs": [ + 0.040255115018226206, + 0.040099431993439794, + 0.04095420497469604, + 0.03987288600183092, + 0.04041685801348649, + 0.040494924993254244, + 0.04049262698390521, + 0.04079927600105293, + 0.04118377499980852, + 0.04038904799381271, + 0.04038159898482263 + ], + "loads_median": 0.09712665400002152, + "loads_min": 0.09544071301934309, + "loads_number": 200000, + "loads_runs": [ + 0.09710476599866524, + 0.09544071301934309, + 0.09796852199360728, + 0.09641282400116324, + 0.09771751399966888, + 0.09875676699448377, + 0.09825973899569362, + 0.09712665400002152, + 0.09814226999878883, + 0.09603261601296254, + 0.0969423119968269 + ] + }, + "nested_dict": { + "dumps_median": 0.07670464701368473, + "dumps_min": 0.07443057300406508, + "dumps_number": 100000, + "dumps_runs": [ + 0.07670464701368473, + 0.0755682380113285, + 0.07518417699611746, + 0.07505606301128864, + 0.07443057300406508, + 0.07728818198665977, + 0.07829541899263859, + 0.07810401200549677, + 0.07622043599258177, + 0.07752709698979743, + 0.07774014701135457 + ], + "loads_median": 0.08734592801192775, + "loads_min": 0.08589171001221985, + "loads_number": 200000, + "loads_runs": [ + 0.08709321398055181, + 0.08734592801192775, + 0.08714917601901107, + 0.08695745901786722, + 0.08589171001221985, + 0.08879310198244639, + 0.08659902500221506, + 0.08748295900295489, + 0.08759746799478307, + 0.08768528798827901, + 0.08783682601642795 + ] + }, + "small_tuple": { + "dumps_median": 0.01571595700806938, + "dumps_min": 0.015293899981770664, + "dumps_number": 100000, + "dumps_runs": [ + 0.01571595700806938, + 0.015348431013990194, + 0.015293899981770664, + 0.015364045015303418, + 0.01530077401548624, + 0.015608929010340944, + 0.015807940013473853, + 0.01611778000369668, + 0.01599793799687177, + 0.01602914900286123, + 0.016072057012934238 + ], + "loads_median": 0.03303753398358822, + "loads_min": 0.032468440011143684, + "loads_number": 200000, + "loads_runs": [ + 0.036123027006397024, + 0.03290336497593671, + 0.032468440011143684, + 0.032748425990575925, + 0.03303753398358822, + 0.033069997996790335, + 0.03337217401713133, + 0.03351389098679647, + 0.033144343993626535, + 0.03277306197560392, + 0.03264542398392223 + ] + } +} diff --git a/Misc/marshal-perf-data/exp1-run1.json b/Misc/marshal-perf-data/exp1-run1.json new file mode 100644 index 00000000000000..4d1158f9d0efeb --- /dev/null +++ b/Misc/marshal-perf-data/exp1-run1.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.04033277300186455, + "dumps_min": 0.03946332598570734, + "dumps_number": 100000, + "dumps_runs": [ + 0.04000187199562788, + 0.04019157501170412, + 0.040330266987439245, + 0.04033277300186455, + 0.0397338549955748, + 0.03946332598570734, + 0.04039332197862677, + 0.04199541499838233, + 0.04090160198393278, + 0.04075628300779499, + 0.04069792199879885 + ], + "loads_median": 0.08819354500155896, + "loads_min": 0.08668907801620662, + "loads_number": 200000, + "loads_runs": [ + 0.08819354500155896, + 0.08829067699844018, + 0.08877010399010032, + 0.08759159001056105, + 0.08731353300390765, + 0.08851525699719787, + 0.08892112999456003, + 0.0888636619783938, + 0.08741689901216887, + 0.08700144200702198, + 0.08668907801620662 + ] + }, + "nested_dict": { + "dumps_median": 0.0747798310185317, + "dumps_min": 0.07363214198267087, + "dumps_number": 100000, + "dumps_runs": [ + 0.07487206000951119, + 0.07434020901564509, + 0.07363214198267087, + 0.07393905601929873, + 0.07417437000549398, + 0.07401381499948911, + 0.07502775898319669, + 0.0747798310185317, + 0.07490334098110907, + 0.07541243100422435, + 0.07540596599574201 + ], + "loads_median": 0.07695655201678164, + "loads_min": 0.07621131101041101, + "loads_number": 200000, + "loads_runs": [ + 0.07695655201678164, + 0.0772451389930211, + 0.0771081320126541, + 0.07685222500003874, + 0.0762724140076898, + 0.07763813901692629, + 0.07782120202318765, + 0.0770820019824896, + 0.07693301400286146, + 0.07621131101041101, + 0.0765539109997917 + ] + }, + "small_tuple": { + "dumps_median": 0.016021739022107795, + "dumps_min": 0.01542763301404193, + "dumps_number": 100000, + "dumps_runs": [ + 0.015788005985086784, + 0.015610786009347066, + 0.01542763301404193, + 0.015559163992293179, + 0.015574525023112074, + 0.016021739022107795, + 0.016197362972889096, + 0.01617900500423275, + 0.016248034982709214, + 0.016283058997942135, + 0.01626910999766551 + ], + "loads_median": 0.025808309990679845, + "loads_min": 0.025438395008677617, + "loads_number": 200000, + "loads_runs": [ + 0.02854208997450769, + 0.02877242097747512, + 0.02603154699318111, + 0.026033326983451843, + 0.02587594700162299, + 0.025438395008677617, + 0.025487111997790635, + 0.025499206996755674, + 0.025469571992289275, + 0.025795752997510135, + 0.025808309990679845 + ] + } +} diff --git a/Misc/marshal-perf-data/exp1-run2.json b/Misc/marshal-perf-data/exp1-run2.json new file mode 100644 index 00000000000000..d50c4378287db1 --- /dev/null +++ b/Misc/marshal-perf-data/exp1-run2.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.040128660009941086, + "dumps_min": 0.03962190798483789, + "dumps_number": 100000, + "dumps_runs": [ + 0.0406871430168394, + 0.040128660009941086, + 0.040314401005161926, + 0.03987122199032456, + 0.040388109016930684, + 0.03962190798483789, + 0.04044658501516096, + 0.040678423014469445, + 0.03972826700191945, + 0.03983127200626768, + 0.040061217994662 + ], + "loads_median": 0.08815862401388586, + "loads_min": 0.0876030680083204, + "loads_number": 200000, + "loads_runs": [ + 0.08855644601862878, + 0.08858073700685054, + 0.0879775210050866, + 0.0879353980126325, + 0.08792218499002047, + 0.08818507700925693, + 0.0876030680083204, + 0.08815862401388586, + 0.08874132699565962, + 0.08846117201028392, + 0.08795679299510084 + ] + }, + "nested_dict": { + "dumps_median": 0.07468327798414975, + "dumps_min": 0.07374477401026525, + "dumps_number": 100000, + "dumps_runs": [ + 0.07436291099293157, + 0.07442475500283763, + 0.0737869779986795, + 0.07384680098039098, + 0.07374477401026525, + 0.07499264500802383, + 0.07538963400293142, + 0.07556400800240226, + 0.07550495598115958, + 0.07468327798414975, + 0.07527458100230433 + ], + "loads_median": 0.0765070709749125, + "loads_min": 0.07577699000830762, + "loads_number": 200000, + "loads_runs": [ + 0.0765070709749125, + 0.07626016400172375, + 0.07600849602022208, + 0.07588227302767336, + 0.07577699000830762, + 0.07682956199278124, + 0.07722289900993928, + 0.07749637399683706, + 0.07838620999245904, + 0.08720817300491035, + 0.0763528480019886 + ] + }, + "small_tuple": { + "dumps_median": 0.01600434197462164, + "dumps_min": 0.015712024993263185, + "dumps_number": 100000, + "dumps_runs": [ + 0.016062307986430824, + 0.015876496996497735, + 0.015794699982507154, + 0.01602680899668485, + 0.015941115008899942, + 0.016140085994265974, + 0.01600434197462164, + 0.015712024993263185, + 0.015955673006828874, + 0.01616553802159615, + 0.01614651599084027 + ], + "loads_median": 0.026310470973839983, + "loads_min": 0.025960957020288333, + "loads_number": 200000, + "loads_runs": [ + 0.025960957020288333, + 0.026310470973839983, + 0.026635541988071054, + 0.026444952003657818, + 0.02598517999285832, + 0.026112480991287157, + 0.026212219992885366, + 0.026348377024987713, + 0.026396252011181787, + 0.026282673003152013, + 0.026451551006175578 + ] + } +} diff --git a/Misc/marshal-perf-data/exp1-run3.json b/Misc/marshal-perf-data/exp1-run3.json new file mode 100644 index 00000000000000..50ac13b28ec51f --- /dev/null +++ b/Misc/marshal-perf-data/exp1-run3.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.039937059016665444, + "dumps_min": 0.03936530300416052, + "dumps_number": 100000, + "dumps_runs": [ + 0.04008360701845959, + 0.03997984298621304, + 0.03936530300416052, + 0.039474652003264055, + 0.039466350979637355, + 0.03981218300759792, + 0.03959059901535511, + 0.039937059016665444, + 0.040519535017665476, + 0.040975163981784135, + 0.040936664008768275 + ], + "loads_median": 0.08741289097815752, + "loads_min": 0.08668841701000929, + "loads_number": 200000, + "loads_runs": [ + 0.0867016970005352, + 0.08706792400334962, + 0.08750296599464491, + 0.08750953001435846, + 0.08703344900277443, + 0.08806307599297725, + 0.08772430900717154, + 0.08761742600472644, + 0.08741289097815752, + 0.08691598198493011, + 0.08668841701000929 + ] + }, + "nested_dict": { + "dumps_median": 0.07604124100180343, + "dumps_min": 0.07287807599641383, + "dumps_number": 100000, + "dumps_runs": [ + 0.07621876100893132, + 0.07317730397335254, + 0.07365713300532661, + 0.07287807599641383, + 0.0739606239949353, + 0.07604124100180343, + 0.07604425499448553, + 0.07635652399039827, + 0.07501802998012863, + 0.07607045100303367, + 0.07619599299505353 + ], + "loads_median": 0.07642375101568177, + "loads_min": 0.07596160200773738, + "loads_number": 200000, + "loads_runs": [ + 0.07719120002002455, + 0.0765697659808211, + 0.0763946780061815, + 0.07642375101568177, + 0.07637938600964844, + 0.07743825201760046, + 0.0760670010058675, + 0.07734032100415789, + 0.07626795500982553, + 0.07660838300944306, + 0.07596160200773738 + ] + }, + "small_tuple": { + "dumps_median": 0.01628588102175854, + "dumps_min": 0.015671332977944985, + "dumps_number": 100000, + "dumps_runs": [ + 0.016070976009359583, + 0.015856407000683248, + 0.015836512990063056, + 0.015671332977944985, + 0.015904113999567926, + 0.01643678199616261, + 0.016315440996550024, + 0.016329085978213698, + 0.01628588102175854, + 0.01664312300272286, + 0.016461335006169975 + ], + "loads_median": 0.025415234005777165, + "loads_min": 0.02517557199462317, + "loads_number": 200000, + "loads_runs": [ + 0.027387512993300334, + 0.026263257983373478, + 0.02593724400503561, + 0.02542449999600649, + 0.02517557199462317, + 0.025415234005777165, + 0.02537413898971863, + 0.025382886989973485, + 0.025318562984466553, + 0.025598132982850075, + 0.025404107000213116 + ] + } +} diff --git a/Misc/marshal-perf-data/exp2-run1.json b/Misc/marshal-perf-data/exp2-run1.json new file mode 100644 index 00000000000000..d0def372755b99 --- /dev/null +++ b/Misc/marshal-perf-data/exp2-run1.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.03913153399480507, + "dumps_min": 0.038401211000746116, + "dumps_number": 100000, + "dumps_runs": [ + 0.039055062021361664, + 0.03954257897567004, + 0.038579008978558704, + 0.038401211000746116, + 0.03923329897224903, + 0.039224445004947484, + 0.039278141979593784, + 0.03913153399480507, + 0.03874181499122642, + 0.039586811006302014, + 0.03854782698908821 + ], + "loads_median": 0.08466412400593981, + "loads_min": 0.0842505140171852, + "loads_number": 200000, + "loads_runs": [ + 0.08483706298284233, + 0.0842505140171852, + 0.08436259598238394, + 0.08475831898977049, + 0.08433498902013525, + 0.0856100789969787, + 0.08466412400593981, + 0.08551535199512728, + 0.08514768502209336, + 0.08442920597735792, + 0.08442747700610198 + ] + }, + "nested_dict": { + "dumps_median": 0.07422846899135038, + "dumps_min": 0.07347129299887456, + "dumps_number": 100000, + "dumps_runs": [ + 0.0740831220173277, + 0.07422846899135038, + 0.07419286097865552, + 0.07432341697858647, + 0.073472705000313, + 0.07347129299887456, + 0.07353575399611145, + 0.0747747849964071, + 0.07454163301736116, + 0.07452338401344605, + 0.07522345901816152 + ], + "loads_median": 0.07290433000889607, + "loads_min": 0.07176484100637026, + "loads_number": 200000, + "loads_runs": [ + 0.07338525899103843, + 0.072042875981424, + 0.07288915201206692, + 0.0730009849939961, + 0.07289892001426779, + 0.07295400300063193, + 0.0727188210003078, + 0.07306211098330095, + 0.0732730680028908, + 0.07176484100637026, + 0.07290433000889607 + ] + }, + "small_tuple": { + "dumps_median": 0.015890426991973072, + "dumps_min": 0.015414587018312886, + "dumps_number": 100000, + "dumps_runs": [ + 0.01593552899430506, + 0.015514884988078848, + 0.015532098012045026, + 0.015414587018312886, + 0.015564990986604244, + 0.015890426991973072, + 0.015910629008430988, + 0.01586949999909848, + 0.01590656500775367, + 0.015938416006974876, + 0.016315132001182064 + ], + "loads_median": 0.024356595997232944, + "loads_min": 0.023907937022158876, + "loads_number": 200000, + "loads_runs": [ + 0.049885585001902655, + 0.025690447015222162, + 0.024119356006849557, + 0.02464109699940309, + 0.02468973700888455, + 0.024643151002237573, + 0.024356595997232944, + 0.023968548979610205, + 0.023907937022158876, + 0.024131242011208087, + 0.024091567989671603 + ] + } +} diff --git a/Misc/marshal-perf-data/exp2-run2.json b/Misc/marshal-perf-data/exp2-run2.json new file mode 100644 index 00000000000000..38f82e2bd049e0 --- /dev/null +++ b/Misc/marshal-perf-data/exp2-run2.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.040365875989664346, + "dumps_min": 0.039371082006255165, + "dumps_number": 100000, + "dumps_runs": [ + 0.04062592098489404, + 0.040365875989664346, + 0.039371082006255165, + 0.03997204900952056, + 0.040704851009650156, + 0.03993129302398302, + 0.04003800099599175, + 0.04048918202170171, + 0.04095534299267456, + 0.04013760699308477, + 0.04042043100344017 + ], + "loads_median": 0.08596367001882754, + "loads_min": 0.08521451300475746, + "loads_number": 200000, + "loads_runs": [ + 0.08547661500051618, + 0.08596367001882754, + 0.08620862601674162, + 0.08602955099195242, + 0.08521451300475746, + 0.08615327201550826, + 0.08594064798671752, + 0.08613825199427083, + 0.08687638002447784, + 0.0854760049842298, + 0.08534193100058474 + ] + }, + "nested_dict": { + "dumps_median": 0.07752293499652296, + "dumps_min": 0.07514425000408664, + "dumps_number": 100000, + "dumps_runs": [ + 0.07938211801229045, + 0.07656012999359518, + 0.07601894700201228, + 0.07514425000408664, + 0.07641170802526176, + 0.07744314501178451, + 0.07780286599881947, + 0.07772468897746876, + 0.07752293499652296, + 0.07900504500139505, + 0.07916373401531018 + ], + "loads_median": 0.07326082198414952, + "loads_min": 0.07208707500831224, + "loads_number": 200000, + "loads_runs": [ + 0.07317563000833616, + 0.07345337999868207, + 0.07208707500831224, + 0.07276268998975866, + 0.07254735101014376, + 0.07801817002473399, + 0.07326082198414952, + 0.07338195998454466, + 0.0732915620028507, + 0.07397833399591036, + 0.07303008800954558 + ] + }, + "small_tuple": { + "dumps_median": 0.01591141999233514, + "dumps_min": 0.015482429997064173, + "dumps_number": 100000, + "dumps_runs": [ + 0.016113856981974095, + 0.015646670013666153, + 0.015516519983066246, + 0.015597493009408936, + 0.015482429997064173, + 0.015879311016760767, + 0.01605030900100246, + 0.01605788999586366, + 0.01591141999233514, + 0.016279272007523105, + 0.016164425003807992 + ], + "loads_median": 0.02390637298231013, + "loads_min": 0.02364749100524932, + "loads_number": 200000, + "loads_runs": [ + 0.027485956001328304, + 0.024215908022597432, + 0.024182714987546206, + 0.023793086991645396, + 0.02390637298231013, + 0.02364749100524932, + 0.02389028499601409, + 0.02429509800276719, + 0.024125641997670755, + 0.0238206590001937, + 0.02369174297200516 + ] + } +} diff --git a/Misc/marshal-perf-data/exp2-run3.json b/Misc/marshal-perf-data/exp2-run3.json new file mode 100644 index 00000000000000..e8c1017b88f0ec --- /dev/null +++ b/Misc/marshal-perf-data/exp2-run3.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.0393497190088965, + "dumps_min": 0.03879433899419382, + "dumps_number": 100000, + "dumps_runs": [ + 0.03966515700449236, + 0.05047771398676559, + 0.03959146299166605, + 0.039640939998207614, + 0.039402052003424615, + 0.038807245990028605, + 0.03922037599841133, + 0.03887919400585815, + 0.0393497190088965, + 0.03879433899419382, + 0.039206616987939924 + ], + "loads_median": 0.08557733098859899, + "loads_min": 0.08428687899140641, + "loads_number": 200000, + "loads_runs": [ + 0.08490244499989785, + 0.08581498402054422, + 0.08481920399935916, + 0.08489080899744295, + 0.08428687899140641, + 0.08688577901921235, + 0.08631522301584482, + 0.08557733098859899, + 0.08732501900522038, + 0.0857719230116345, + 0.08491555898217484 + ] + }, + "nested_dict": { + "dumps_median": 0.07442531999549828, + "dumps_min": 0.07345920702209696, + "dumps_number": 100000, + "dumps_runs": [ + 0.07442531999549828, + 0.07432982200407423, + 0.07345920702209696, + 0.07438734397874214, + 0.07441161799943075, + 0.07505954898078926, + 0.0744091130036395, + 0.07573507900815457, + 0.07533466099994257, + 0.07558907999191433, + 0.07632700097747147 + ], + "loads_median": 0.07283339000423439, + "loads_min": 0.07138665800448507, + "loads_number": 200000, + "loads_runs": [ + 0.07138665800448507, + 0.07338458500453271, + 0.07214288000250235, + 0.07310372201027349, + 0.07283339000423439, + 0.07311398201272823, + 0.07358088801265694, + 0.07348914601607248, + 0.07191488501848653, + 0.07263224499183707, + 0.07227559000602923 + ] + }, + "small_tuple": { + "dumps_median": 0.015749871003208682, + "dumps_min": 0.01552099600667134, + "dumps_number": 100000, + "dumps_runs": [ + 0.015844023000681773, + 0.015749871003208682, + 0.01570163099677302, + 0.01559801198891364, + 0.015613038995070383, + 0.01594732899684459, + 0.016256773989880458, + 0.016164658998604864, + 0.01593803000287153, + 0.01552099600667134, + 0.015612073999363929 + ], + "loads_median": 0.02466359900427051, + "loads_min": 0.024007775995414704, + "loads_number": 200000, + "loads_runs": [ + 0.02494844197644852, + 0.024875390983652323, + 0.024956801993539557, + 0.02502959599951282, + 0.024306639010319486, + 0.02427358101704158, + 0.02415605800342746, + 0.024007775995414704, + 0.02459115401143208, + 0.02466359900427051, + 0.024762597982771695 + ] + } +} diff --git a/Misc/marshal-perf-data/exp3-run1.json b/Misc/marshal-perf-data/exp3-run1.json new file mode 100644 index 00000000000000..09272b129ea1e4 --- /dev/null +++ b/Misc/marshal-perf-data/exp3-run1.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.039693729020655155, + "dumps_min": 0.039088585996069014, + "dumps_number": 100000, + "dumps_runs": [ + 0.040260420995764434, + 0.039693729020655155, + 0.039885843987576663, + 0.039088585996069014, + 0.03923555801156908, + 0.039816031989175826, + 0.0400355150050018, + 0.03977335398667492, + 0.039189978007925674, + 0.03939645300852135, + 0.03924433601787314 + ], + "loads_median": 0.0990410310041625, + "loads_min": 0.09645016698050313, + "loads_number": 200000, + "loads_runs": [ + 0.0990410310041625, + 0.09709951101103798, + 0.09848101899842732, + 0.0994938229850959, + 0.09968218699214049, + 0.09892859600950032, + 0.0993907340161968, + 0.10115482099354267, + 0.11913959999219514, + 0.09804376898682676, + 0.09645016698050313 + ] + }, + "nested_dict": { + "dumps_median": 0.07671320001827553, + "dumps_min": 0.0757579859928228, + "dumps_number": 100000, + "dumps_runs": [ + 0.07617233297787607, + 0.07712809400982223, + 0.07689569500507787, + 0.07706775999395177, + 0.07609823500388302, + 0.0757579859928228, + 0.07671320001827553, + 0.07650720898527652, + 0.07617059300537221, + 0.0768989079806488, + 0.07719208399066702 + ], + "loads_median": 0.08628589697764255, + "loads_min": 0.08531746600056067, + "loads_number": 200000, + "loads_runs": [ + 0.08531746600056067, + 0.08600144000956789, + 0.08568010301678441, + 0.08672074400237761, + 0.08629751100670546, + 0.08577954099746421, + 0.0864096789737232, + 0.08730222700978629, + 0.08715668501099572, + 0.08628589697764255, + 0.08611975601525046 + ] + }, + "small_tuple": { + "dumps_median": 0.016093796002678573, + "dumps_min": 0.01571961000445299, + "dumps_number": 100000, + "dumps_runs": [ + 0.016133817000081763, + 0.0158265579957515, + 0.015917177021037787, + 0.01571961000445299, + 0.016093796002678573, + 0.016310370003338903, + 0.01614851798512973, + 0.01614343299297616, + 0.01608028498594649, + 0.01609206001739949, + 0.016416742000728846 + ], + "loads_median": 0.03350025200052187, + "loads_min": 0.03313866999815218, + "loads_number": 200000, + "loads_runs": [ + 0.03968982197693549, + 0.03555103499093093, + 0.03313866999815218, + 0.03329878501244821, + 0.03341616099351086, + 0.03363919400726445, + 0.03350025200052187, + 0.03329093899810687, + 0.03327572499983944, + 0.03391860501142219, + 0.03400543099269271 + ] + } +} diff --git a/Misc/marshal-perf-data/exp3-run2.json b/Misc/marshal-perf-data/exp3-run2.json new file mode 100644 index 00000000000000..416a371ff52e2b --- /dev/null +++ b/Misc/marshal-perf-data/exp3-run2.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.04111989701050334, + "dumps_min": 0.04069254899513908, + "dumps_number": 100000, + "dumps_runs": [ + 0.04069254899513908, + 0.040956362994620577, + 0.04111989701050334, + 0.04112529297708534, + 0.04108718197676353, + 0.04118439799640328, + 0.04132323700468987, + 0.04109985998366028, + 0.04103079598280601, + 0.04119024600367993, + 0.041489319992251694 + ], + "loads_median": 0.09785455701057799, + "loads_min": 0.09583439902053215, + "loads_number": 200000, + "loads_runs": [ + 0.09815674999845214, + 0.09796374701545574, + 0.09583439902053215, + 0.09785455701057799, + 0.09769536598469131, + 0.09899815201060846, + 0.0976886389835272, + 0.09909531599259935, + 0.09953428199514747, + 0.0977489159849938, + 0.09765372998663224 + ] + }, + "nested_dict": { + "dumps_median": 0.07611127599375322, + "dumps_min": 0.07480365200899541, + "dumps_number": 100000, + "dumps_runs": [ + 0.07655478199012578, + 0.0759814880148042, + 0.07611127599375322, + 0.07640160198207013, + 0.07955891900928691, + 0.07808496200595982, + 0.07480365200899541, + 0.07593616700614803, + 0.07509007200133055, + 0.07671506598126143, + 0.07544562598923221 + ], + "loads_median": 0.0872108529729303, + "loads_min": 0.08492490099160932, + "loads_number": 200000, + "loads_runs": [ + 0.08633478698902763, + 0.08552488900022581, + 0.08522302599158138, + 0.08621830600895919, + 0.08492490099160932, + 0.08798018199740909, + 0.08727689000079408, + 0.08790307797607966, + 0.0876340240065474, + 0.0872108529729303, + 0.10170821900828741 + ] + }, + "small_tuple": { + "dumps_median": 0.01574900301056914, + "dumps_min": 0.0156449849891942, + "dumps_number": 100000, + "dumps_runs": [ + 0.015839080006117, + 0.01567636599065736, + 0.01570625600288622, + 0.01581552400602959, + 0.01574900301056914, + 0.01574510900536552, + 0.015777795983012766, + 0.0156449849891942, + 0.015712189982878044, + 0.01612417501746677, + 0.016040560003602877 + ], + "loads_median": 0.03358469597878866, + "loads_min": 0.03302783900289796, + "loads_number": 200000, + "loads_runs": [ + 0.03552775000571273, + 0.03358469597878866, + 0.03316539799561724, + 0.03302783900289796, + 0.03305656198062934, + 0.0335238839907106, + 0.03352890000678599, + 0.033682156004942954, + 0.03397326701087877, + 0.03364858400891535, + 0.033947233023354784 + ] + } +} diff --git a/Misc/marshal-perf-data/exp3-run3.json b/Misc/marshal-perf-data/exp3-run3.json new file mode 100644 index 00000000000000..7d8a04cd7aa5e5 --- /dev/null +++ b/Misc/marshal-perf-data/exp3-run3.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.040469889994710684, + "dumps_min": 0.03972134701325558, + "dumps_number": 100000, + "dumps_runs": [ + 0.041280953999375924, + 0.04050064898910932, + 0.04041862199665047, + 0.040927497000666335, + 0.040469889994710684, + 0.040370981994783506, + 0.03972134701325558, + 0.04063531500287354, + 0.0405171439924743, + 0.040321742999367416, + 0.03989395502139814 + ], + "loads_median": 0.09751285699894652, + "loads_min": 0.09605396498227492, + "loads_number": 200000, + "loads_runs": [ + 0.097969969996484, + 0.09719703797600232, + 0.09605396498227492, + 0.09729385600076057, + 0.09751285699894652, + 0.09969933002139442, + 0.10022979200584814, + 0.09803043701685965, + 0.099387572001433, + 0.09724014098173939, + 0.09660298799281009 + ] + }, + "nested_dict": { + "dumps_median": 0.07668981701135635, + "dumps_min": 0.07512810599291697, + "dumps_number": 100000, + "dumps_runs": [ + 0.07537533997674473, + 0.07512810599291697, + 0.07668981701135635, + 0.0775050460069906, + 0.07599275399115868, + 0.07757212300202809, + 0.07668698497582227, + 0.07573643000796437, + 0.07720816298387945, + 0.07737276700208895, + 0.0771377439959906 + ], + "loads_median": 0.08524103599484079, + "loads_min": 0.08468884098692797, + "loads_number": 200000, + "loads_runs": [ + 0.08524103599484079, + 0.08504921800340526, + 0.08468884098692797, + 0.08515926299151033, + 0.08599091999349184, + 0.08648093297961168, + 0.08638241401058622, + 0.08543866898980923, + 0.08619317400734872, + 0.08483731700107455, + 0.08512348198564723 + ] + }, + "small_tuple": { + "dumps_median": 0.015779965004185215, + "dumps_min": 0.015624831023160368, + "dumps_number": 100000, + "dumps_runs": [ + 0.0156265209952835, + 0.015624831023160368, + 0.015690611995523795, + 0.015655339986551553, + 0.01576503098476678, + 0.016021470015402883, + 0.016083301976323128, + 0.015966473991284147, + 0.015779965004185215, + 0.01594615200883709, + 0.015961124998284504 + ], + "loads_median": 0.034273899014806375, + "loads_min": 0.033652759972028434, + "loads_number": 200000, + "loads_runs": [ + 0.03595512401079759, + 0.03389828198123723, + 0.03398171698790975, + 0.034273899014806375, + 0.034044896019622684, + 0.034401673008687794, + 0.03436313700512983, + 0.03460289299255237, + 0.03477732799365185, + 0.03390376700554043, + 0.033652759972028434 + ] + } +} diff --git a/Misc/marshal-perf-data/exp4-run1.json b/Misc/marshal-perf-data/exp4-run1.json new file mode 100644 index 00000000000000..02e716729e4463 --- /dev/null +++ b/Misc/marshal-perf-data/exp4-run1.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.03975673299282789, + "dumps_min": 0.03944370098179206, + "dumps_number": 100000, + "dumps_runs": [ + 0.03975673299282789, + 0.03953910298878327, + 0.03995437402045354, + 0.040252323989989236, + 0.039573745016241446, + 0.03951452299952507, + 0.04017469100654125, + 0.03961644400260411, + 0.03944370098179206, + 0.040511340979719535, + 0.041048937011510134 + ], + "loads_median": 0.09769234000123106, + "loads_min": 0.09639323898591101, + "loads_number": 200000, + "loads_runs": [ + 0.09639323898591101, + 0.09769234000123106, + 0.09769219800364226, + 0.09841696001240052, + 0.09833638300187886, + 0.09876783998333849, + 0.09758354802033864, + 0.09841823700116947, + 0.09882358097820543, + 0.09676254499936476, + 0.09767631199792959 + ] + }, + "nested_dict": { + "dumps_median": 0.07736984599614516, + "dumps_min": 0.07502956499229185, + "dumps_number": 100000, + "dumps_runs": [ + 0.07864178699674085, + 0.07502956499229185, + 0.07573351199971512, + 0.07575912601896562, + 0.07673834002343938, + 0.07755983201786876, + 0.07834624999668449, + 0.07736984599614516, + 0.07723590600653552, + 0.07769632898271084, + 0.07781806800630875 + ], + "loads_median": 0.08741990098496899, + "loads_min": 0.08595812399289571, + "loads_number": 200000, + "loads_runs": [ + 0.08811757699004374, + 0.08595812399289571, + 0.08722720001242124, + 0.08741990098496899, + 0.08766519601340406, + 0.08712187400669791, + 0.08643463198677637, + 0.08764934100327082, + 0.08859490702161565, + 0.08804087500902824, + 0.0872372779995203 + ] + }, + "small_tuple": { + "dumps_median": 0.01570142898708582, + "dumps_min": 0.015627938002580777, + "dumps_number": 100000, + "dumps_runs": [ + 0.0160004619974643, + 0.01566394601832144, + 0.015671877976274118, + 0.015700985008152202, + 0.01597857300657779, + 0.015730203012935817, + 0.01570142898708582, + 0.015627938002580777, + 0.015698115021223202, + 0.015965705999406055, + 0.01594122900860384 + ], + "loads_median": 0.031456347001949325, + "loads_min": 0.030955030990298837, + "loads_number": 200000, + "loads_runs": [ + 0.0366436849872116, + 0.03414024997618981, + 0.03124608498183079, + 0.03108266700292006, + 0.030955030990298837, + 0.031456347001949325, + 0.03196773200761527, + 0.03202320498530753, + 0.03160808200482279, + 0.031083843001397327, + 0.03133734498987906 + ] + } +} diff --git a/Misc/marshal-perf-data/exp4-run2.json b/Misc/marshal-perf-data/exp4-run2.json new file mode 100644 index 00000000000000..2fdf787d64d6dc --- /dev/null +++ b/Misc/marshal-perf-data/exp4-run2.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.04003325299709104, + "dumps_min": 0.03971633399487473, + "dumps_number": 100000, + "dumps_runs": [ + 0.03971633399487473, + 0.03981904900865629, + 0.040859175991499797, + 0.039967663993593305, + 0.039942894014529884, + 0.04009685799246654, + 0.039911399013362825, + 0.040574660000856966, + 0.040347481990465894, + 0.04003325299709104, + 0.04037725500529632 + ], + "loads_median": 0.0968055420089513, + "loads_min": 0.09524353599408641, + "loads_number": 200000, + "loads_runs": [ + 0.09674708600505255, + 0.0968055420089513, + 0.09698522998951375, + 0.09524353599408641, + 0.09810481200111099, + 0.09801127598620951, + 0.09779097102000378, + 0.09851611300837249, + 0.09658848799881525, + 0.09597644399036653, + 0.09615278601995669 + ] + }, + "nested_dict": { + "dumps_median": 0.07649466901784763, + "dumps_min": 0.07562962401425466, + "dumps_number": 100000, + "dumps_runs": [ + 0.07628630398539826, + 0.07562962401425466, + 0.07623490600963123, + 0.07573171000694856, + 0.07635326602030545, + 0.07758896698942408, + 0.07746968598803505, + 0.07781540200812742, + 0.07649466901784763, + 0.07650690199807286, + 0.07750423598918132 + ], + "loads_median": 0.08708067500265315, + "loads_min": 0.08616343897301704, + "loads_number": 200000, + "loads_runs": [ + 0.08663818298373371, + 0.08665969999856316, + 0.08708280199789442, + 0.08616343897301704, + 0.08759379500406794, + 0.09325845100102015, + 0.08952928701182827, + 0.08777712698793039, + 0.08622840899624862, + 0.08708067500265315, + 0.08647746502538212 + ] + }, + "small_tuple": { + "dumps_median": 0.015583209984470159, + "dumps_min": 0.015327414002967998, + "dumps_number": 100000, + "dumps_runs": [ + 0.015664695005398244, + 0.01544955899589695, + 0.015696232992922887, + 0.015400134987430647, + 0.015327414002967998, + 0.015583209984470159, + 0.015440962015418336, + 0.01545342500321567, + 0.015636263007763773, + 0.016162779997102916, + 0.0157533309829887 + ], + "loads_median": 0.03213569498620927, + "loads_min": 0.03124660300090909, + "loads_number": 200000, + "loads_runs": [ + 0.03444643798866309, + 0.03225942701101303, + 0.032152781990589574, + 0.03189903899328783, + 0.03213569498620927, + 0.03233484900556505, + 0.03242776601109654, + 0.03170303700608201, + 0.03144849100499414, + 0.03124660300090909, + 0.031839951989240944 + ] + } +} diff --git a/Misc/marshal-perf-data/exp4-run3.json b/Misc/marshal-perf-data/exp4-run3.json new file mode 100644 index 00000000000000..c452f762d21f39 --- /dev/null +++ b/Misc/marshal-perf-data/exp4-run3.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.0397031249885913, + "dumps_min": 0.03889491700101644, + "dumps_number": 100000, + "dumps_runs": [ + 0.0397031249885913, + 0.0394766450044699, + 0.03956987999845296, + 0.03889491700101644, + 0.04037026400328614, + 0.04029770000488497, + 0.040115502022672445, + 0.04014677301165648, + 0.03956555301556364, + 0.03975647399784066, + 0.03947280300781131 + ], + "loads_median": 0.09857030800776556, + "loads_min": 0.09470037400024012, + "loads_number": 200000, + "loads_runs": [ + 0.11290037000435404, + 0.09859778298414312, + 0.09885233998647891, + 0.09857030800776556, + 0.0969928500126116, + 0.09898433097987436, + 0.0977904920000583, + 0.09916590401553549, + 0.09778029899462126, + 0.09470037400024012, + 0.09669189399573952 + ] + }, + "nested_dict": { + "dumps_median": 0.07649231801042333, + "dumps_min": 0.07615492300828919, + "dumps_number": 100000, + "dumps_runs": [ + 0.0766653070168104, + 0.07637896100641228, + 0.07657137300702743, + 0.07649231801042333, + 0.07615492300828919, + 0.0763835069956258, + 0.0765523389854934, + 0.07736021600430831, + 0.07652921898989007, + 0.07634501601569355, + 0.0764185699808877 + ], + "loads_median": 0.08864274399820715, + "loads_min": 0.08750853699166328, + "loads_number": 200000, + "loads_runs": [ + 0.08878635699511506, + 0.08822815399616957, + 0.08864274399820715, + 0.08830633701290935, + 0.08784249899326824, + 0.08961282798554748, + 0.08946072001708671, + 0.08958637900650501, + 0.08926297101425007, + 0.08838462800486013, + 0.08750853699166328 + ] + }, + "small_tuple": { + "dumps_median": 0.015620199003024027, + "dumps_min": 0.015172668994637206, + "dumps_number": 100000, + "dumps_runs": [ + 0.015561478008748963, + 0.015471024002181366, + 0.015172668994637206, + 0.015865977999055758, + 0.015396514994790778, + 0.015620199003024027, + 0.015682130004279315, + 0.015684723999584094, + 0.015596501994878054, + 0.015786517004016787, + 0.015854237019084394 + ], + "loads_median": 0.0322349029884208, + "loads_min": 0.031186766020255163, + "loads_number": 200000, + "loads_runs": [ + 0.035428079980192706, + 0.03266548700048588, + 0.03213300000061281, + 0.0322349029884208, + 0.03174468199722469, + 0.03237177801202051, + 0.0327420620014891, + 0.03251955099403858, + 0.032024656975409016, + 0.031186766020255163, + 0.03141336201224476 + ] + } +} diff --git a/Misc/marshal-perf-data/exp5-run1.json b/Misc/marshal-perf-data/exp5-run1.json new file mode 100644 index 00000000000000..5727a501b70bb1 --- /dev/null +++ b/Misc/marshal-perf-data/exp5-run1.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.03939943399745971, + "dumps_min": 0.039031407999573275, + "dumps_number": 100000, + "dumps_runs": [ + 0.03939943399745971, + 0.039031407999573275, + 0.039239931997144595, + 0.03988463198766112, + 0.039173572993604466, + 0.03931394300889224, + 0.03924533200915903, + 0.04012322399648838, + 0.03950509399874136, + 0.0405767040210776, + 0.04014071502024308 + ], + "loads_median": 0.09740636302740313, + "loads_min": 0.09611935901921242, + "loads_number": 200000, + "loads_runs": [ + 0.09740636302740313, + 0.09669790501357056, + 0.09706207597628236, + 0.09611935901921242, + 0.09699423599522561, + 0.09884049597894773, + 0.09748926098109223, + 0.09830249100923538, + 0.09871918501448818, + 0.09709252501488663, + 0.09761450299993157 + ] + }, + "nested_dict": { + "dumps_median": 0.07515301698003896, + "dumps_min": 0.07309790700674057, + "dumps_number": 100000, + "dumps_runs": [ + 0.07540271399193443, + 0.07426038198173046, + 0.07329402898903936, + 0.07354322698665783, + 0.07309790700674057, + 0.07600851901224814, + 0.07523583999136463, + 0.07484431797638535, + 0.07515301698003896, + 0.07577219398808666, + 0.07626584099489264 + ], + "loads_median": 0.08601537498179823, + "loads_min": 0.08554518298478797, + "loads_number": 200000, + "loads_runs": [ + 0.08597875799750909, + 0.08591956598684192, + 0.08616683699074201, + 0.0861662859970238, + 0.08554518298478797, + 0.08654552898951806, + 0.08601537498179823, + 0.08618534301058389, + 0.08575531298993155, + 0.08583637600531802, + 0.08629614001256414 + ] + }, + "small_tuple": { + "dumps_median": 0.015413204993819818, + "dumps_min": 0.015096871997229755, + "dumps_number": 100000, + "dumps_runs": [ + 0.015351475012721494, + 0.015096871997229755, + 0.015161420014919713, + 0.015217570005916059, + 0.015318416990339756, + 0.015413204993819818, + 0.015487989003304392, + 0.01587405300233513, + 0.015526481001870707, + 0.015690102009102702, + 0.015572517993859947 + ], + "loads_median": 0.032345346990041435, + "loads_min": 0.03202727701864205, + "loads_number": 200000, + "loads_runs": [ + 0.03731047100154683, + 0.03553375898627564, + 0.03202727701864205, + 0.032330510002793744, + 0.032183724018977955, + 0.03231194199179299, + 0.03287880000425503, + 0.032345346990041435, + 0.032579225982772186, + 0.03280611100490205, + 0.03228177598793991 + ] + } +} diff --git a/Misc/marshal-perf-data/exp5-run2.json b/Misc/marshal-perf-data/exp5-run2.json new file mode 100644 index 00000000000000..e30417f7082c1e --- /dev/null +++ b/Misc/marshal-perf-data/exp5-run2.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.039655216998653486, + "dumps_min": 0.03897982300259173, + "dumps_number": 100000, + "dumps_runs": [ + 0.04003289298270829, + 0.039655216998653486, + 0.039788782014511526, + 0.040243480005301535, + 0.039721606008242816, + 0.03910924299270846, + 0.03897982300259173, + 0.039046295976731926, + 0.0395726709975861, + 0.0399820169841405, + 0.039430384000297636 + ], + "loads_median": 0.09656345201074146, + "loads_min": 0.0956655390036758, + "loads_number": 200000, + "loads_runs": [ + 0.0957722159801051, + 0.0964163489989005, + 0.09656345201074146, + 0.0963616649969481, + 0.09718266400159337, + 0.09793523600092158, + 0.09803605900378898, + 0.09846642400952987, + 0.09700141099165194, + 0.0956655390036758, + 0.09600470098666847 + ] + }, + "nested_dict": { + "dumps_median": 0.07599549897713587, + "dumps_min": 0.07355758399353363, + "dumps_number": 100000, + "dumps_runs": [ + 0.07555916300043464, + 0.07355758399353363, + 0.07479488098761067, + 0.07376570199267007, + 0.07356668700231239, + 0.07723341198288836, + 0.0772046160127502, + 0.07687992599676363, + 0.07599549897713587, + 0.07748023298336193, + 0.07730556101887487 + ], + "loads_median": 0.08633519598515704, + "loads_min": 0.08508942200569436, + "loads_number": 200000, + "loads_runs": [ + 0.08581645297817886, + 0.08508942200569436, + 0.08540875700418837, + 0.09031834901543334, + 0.08600754599319771, + 0.08694155799457803, + 0.08677487997920252, + 0.08691424899734557, + 0.08724493702175096, + 0.0855981330096256, + 0.08633519598515704 + ] + }, + "small_tuple": { + "dumps_median": 0.015156516979914159, + "dumps_min": 0.014837046997854486, + "dumps_number": 100000, + "dumps_runs": [ + 0.015143912984058261, + 0.01491481700213626, + 0.014837046997854486, + 0.014945486997021362, + 0.01487162199919112, + 0.015184614021563902, + 0.01516481299768202, + 0.015156516979914159, + 0.015469607984414324, + 0.015442512987647206, + 0.01568574897828512 + ], + "loads_median": 0.03204882101272233, + "loads_min": 0.03143184501095675, + "loads_number": 200000, + "loads_runs": [ + 0.03219844200066291, + 0.03166749799856916, + 0.03151211902149953, + 0.0321219660108909, + 0.03204882101272233, + 0.03187699298723601, + 0.0322077370074112, + 0.03216885501751676, + 0.03207867799210362, + 0.031476987001951784, + 0.03143184501095675 + ] + } +} diff --git a/Misc/marshal-perf-data/exp5-run3.json b/Misc/marshal-perf-data/exp5-run3.json new file mode 100644 index 00000000000000..531a3bdd1d585b --- /dev/null +++ b/Misc/marshal-perf-data/exp5-run3.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.03902255999855697, + "dumps_min": 0.03851095400750637, + "dumps_number": 100000, + "dumps_runs": [ + 0.038543755013961345, + 0.03862034800113179, + 0.0392041290178895, + 0.03923385898815468, + 0.03894245598348789, + 0.03936411300674081, + 0.03941565298009664, + 0.03964091499801725, + 0.03902255999855697, + 0.03892998700030148, + 0.03851095400750637 + ], + "loads_median": 0.09685701399575919, + "loads_min": 0.09566936400369741, + "loads_number": 200000, + "loads_runs": [ + 0.09618862200295553, + 0.09698648701305501, + 0.09680947897140868, + 0.09829894098220393, + 0.09717365700635128, + 0.0982637979905121, + 0.09685701399575919, + 0.09754851702018641, + 0.09684908599592745, + 0.09566936400369741, + 0.09635606699157506 + ] + }, + "nested_dict": { + "dumps_median": 0.07424918402102776, + "dumps_min": 0.07344485700014047, + "dumps_number": 100000, + "dumps_runs": [ + 0.07424918402102776, + 0.07344485700014047, + 0.07487033700454049, + 0.07368812800268643, + 0.07400730199879035, + 0.07461570602026768, + 0.07442846699268557, + 0.07459089500480331, + 0.0739321029977873, + 0.07555678498465568, + 0.07397886301623657 + ], + "loads_median": 0.08565101400017738, + "loads_min": 0.08469424198847264, + "loads_number": 200000, + "loads_runs": [ + 0.08618206600658596, + 0.08586305700009689, + 0.08564902501530014, + 0.08479765098309144, + 0.08469424198847264, + 0.08602775499457493, + 0.08547963199089281, + 0.08606613401207142, + 0.08565101400017738, + 0.08506381598999724, + 0.0903227069939021 + ] + }, + "small_tuple": { + "dumps_median": 0.01534404800622724, + "dumps_min": 0.01491805599653162, + "dumps_number": 100000, + "dumps_runs": [ + 0.015385906997835264, + 0.015149744023801759, + 0.01491805599653162, + 0.014987795002525672, + 0.015272674994776025, + 0.01534404800622724, + 0.015414786990731955, + 0.015145450015552342, + 0.015729205013485625, + 0.01579365902580321, + 0.01563760099816136 + ], + "loads_median": 0.03194750699913129, + "loads_min": 0.03133169302600436, + "loads_number": 200000, + "loads_runs": [ + 0.0347510069841519, + 0.03200374500011094, + 0.03165073398849927, + 0.031544747995212674, + 0.03133169302600436, + 0.031675992999225855, + 0.046400108985835686, + 0.03194750699913129, + 0.03242636099457741, + 0.032226386974798515, + 0.03185591599321924 + ] + } +} diff --git a/Misc/marshal-perf-data/exp6-run1.json b/Misc/marshal-perf-data/exp6-run1.json new file mode 100644 index 00000000000000..7e4e94b4f93a1b --- /dev/null +++ b/Misc/marshal-perf-data/exp6-run1.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.03966856200713664, + "dumps_min": 0.03916430298704654, + "dumps_number": 100000, + "dumps_runs": [ + 0.04007462499430403, + 0.040240846981760114, + 0.03963588998885825, + 0.03916430298704654, + 0.03925951602286659, + 0.03978731599636376, + 0.039818674995331094, + 0.03941572300391272, + 0.039321599004324526, + 0.03966856200713664, + 0.03975851900759153 + ], + "loads_median": 0.09608539499458857, + "loads_min": 0.09452613498433493, + "loads_number": 200000, + "loads_runs": [ + 0.09555116499541327, + 0.09666199798812158, + 0.09571241398225538, + 0.09726938998210244, + 0.09586278401548043, + 0.09733475800021552, + 0.09608539499458857, + 0.09683976002270356, + 0.09643236399278976, + 0.09452613498433493, + 0.09477390101528727 + ] + }, + "nested_dict": { + "dumps_median": 0.07499821702367626, + "dumps_min": 0.07394831700366922, + "dumps_number": 100000, + "dumps_runs": [ + 0.07527173400740139, + 0.07576455597882159, + 0.07536636598524638, + 0.0748062290076632, + 0.07394831700366922, + 0.07499821702367626, + 0.07400123900151812, + 0.07468906400026754, + 0.07447534499806352, + 0.07580252201296389, + 0.07594150400836952 + ], + "loads_median": 0.08585420198505744, + "loads_min": 0.08490396998240612, + "loads_number": 200000, + "loads_runs": [ + 0.08634045298094861, + 0.08523761198739521, + 0.08585420198505744, + 0.08490396998240612, + 0.08506189298350364, + 0.0861954600259196, + 0.08543998299865052, + 0.08579624799313024, + 0.09144783599185757, + 0.08720592499594204, + 0.08612115998403169 + ] + }, + "small_tuple": { + "dumps_median": 0.0157957439951133, + "dumps_min": 0.015402568009449169, + "dumps_number": 100000, + "dumps_runs": [ + 0.0157957439951133, + 0.015527607989497483, + 0.015474954998353496, + 0.015552264987491071, + 0.015402568009449169, + 0.01603384700138122, + 0.0159380919940304, + 0.015939625998726115, + 0.015640454017557204, + 0.016081951995147392, + 0.016149927978403866 + ], + "loads_median": 0.032523602014407516, + "loads_min": 0.03169997001532465, + "loads_number": 200000, + "loads_runs": [ + 0.038072800991358235, + 0.03691517101833597, + 0.0323739749728702, + 0.03193840698804706, + 0.03169997001532465, + 0.032401595992268994, + 0.03275634199962951, + 0.032523602014407516, + 0.03268824898987077, + 0.03263136601890437, + 0.032101126009365544 + ] + } +} diff --git a/Misc/marshal-perf-data/exp6-run2.json b/Misc/marshal-perf-data/exp6-run2.json new file mode 100644 index 00000000000000..d9789730e8f2f9 --- /dev/null +++ b/Misc/marshal-perf-data/exp6-run2.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.0395883790042717, + "dumps_min": 0.03931739099789411, + "dumps_number": 100000, + "dumps_runs": [ + 0.04036078599165194, + 0.03955762198893353, + 0.03945943899452686, + 0.039516450982773677, + 0.04018558200914413, + 0.03931739099789411, + 0.0395883790042717, + 0.039528181980131194, + 0.03973897799733095, + 0.03963927100994624, + 0.039985665993299335 + ], + "loads_median": 0.09747046299162321, + "loads_min": 0.09633932998985983, + "loads_number": 200000, + "loads_runs": [ + 0.09747046299162321, + 0.09660433701355942, + 0.09663502499461174, + 0.0977886939945165, + 0.09771506098331884, + 0.0976716440054588, + 0.09805636102100834, + 0.09694694299832918, + 0.0975032729911618, + 0.09633932998985983, + 0.096401322982274 + ] + }, + "nested_dict": { + "dumps_median": 0.07600613700924441, + "dumps_min": 0.07390862700412981, + "dumps_number": 100000, + "dumps_runs": [ + 0.07606178199057467, + 0.07390862700412981, + 0.07420001798891462, + 0.07417714098119177, + 0.0753271949943155, + 0.0763199929788243, + 0.07600613700924441, + 0.07621918700169772, + 0.0752234350075014, + 0.07752764399629086, + 0.07722164900042117 + ], + "loads_median": 0.08489330098382197, + "loads_min": 0.08402049099095166, + "loads_number": 200000, + "loads_runs": [ + 0.0860911070194561, + 0.0843878309824504, + 0.08573582101962529, + 0.08466119898366742, + 0.08402049099095166, + 0.08476648799842224, + 0.0862493570020888, + 0.08630041201831773, + 0.08532470199861564, + 0.08489330098382197, + 0.08484527497785166 + ] + }, + "small_tuple": { + "dumps_median": 0.015789180004503578, + "dumps_min": 0.015269729017745703, + "dumps_number": 100000, + "dumps_runs": [ + 0.015633306000381708, + 0.01534937901305966, + 0.015269729017745703, + 0.015651257999707013, + 0.015575244004139677, + 0.015789180004503578, + 0.015935049013933167, + 0.015926698019029573, + 0.01588276302209124, + 0.015995858993846923, + 0.016154066019225866 + ], + "loads_median": 0.03282197497901507, + "loads_min": 0.03217609800049104, + "loads_number": 200000, + "loads_runs": [ + 0.03570213200873695, + 0.03282197497901507, + 0.032641930010868236, + 0.03217609800049104, + 0.03243581499555148, + 0.03264819199102931, + 0.03394922101870179, + 0.033430518000386655, + 0.032897102006245404, + 0.03249825301463716, + 0.03285849900566973 + ] + } +} diff --git a/Misc/marshal-perf-data/exp6-run3.json b/Misc/marshal-perf-data/exp6-run3.json new file mode 100644 index 00000000000000..c18dd9bc155635 --- /dev/null +++ b/Misc/marshal-perf-data/exp6-run3.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.039777502999641, + "dumps_min": 0.039136829000199214, + "dumps_number": 100000, + "dumps_runs": [ + 0.0398400490230415, + 0.03916832400136627, + 0.03933768000570126, + 0.04002393499831669, + 0.040250903024571016, + 0.039795200020307675, + 0.039456686994526535, + 0.039136829000199214, + 0.04008592400350608, + 0.039777502999641, + 0.039349300001049414 + ], + "loads_median": 0.09641031897626817, + "loads_min": 0.0944926569936797, + "loads_number": 200000, + "loads_runs": [ + 0.09656659100437537, + 0.09667671599891037, + 0.09568127599777654, + 0.09551197700784542, + 0.09611217200290412, + 0.09641031897626817, + 0.09737832800601609, + 0.09848202098510228, + 0.09716691597714089, + 0.09574945000349544, + 0.0944926569936797 + ] + }, + "nested_dict": { + "dumps_median": 0.07693648998974822, + "dumps_min": 0.07396814299863763, + "dumps_number": 100000, + "dumps_runs": [ + 0.07693648998974822, + 0.07460888201603666, + 0.07422137798857875, + 0.07423210600973107, + 0.07396814299863763, + 0.07719907100545242, + 0.07768533498165198, + 0.07728190699708648, + 0.07673511697794311, + 0.07731224299641326, + 0.07782476599095389 + ], + "loads_median": 0.0868583670235239, + "loads_min": 0.08380848300294019, + "loads_number": 200000, + "loads_runs": [ + 0.08672686101635918, + 0.08705785300116986, + 0.08634261399856769, + 0.08639226300874725, + 0.08718991198111326, + 0.08732622399111278, + 0.08691365298000164, + 0.08776164200389758, + 0.0868583670235239, + 0.08380848300294019, + 0.0839081059966702 + ] + }, + "small_tuple": { + "dumps_median": 0.01561501799733378, + "dumps_min": 0.015355670999269933, + "dumps_number": 100000, + "dumps_runs": [ + 0.01588871600688435, + 0.015741711016744375, + 0.015454473003046587, + 0.015355670999269933, + 0.015439147013239563, + 0.015700635995017365, + 0.01561501799733378, + 0.015596958983223885, + 0.015555329009657726, + 0.01608268398558721, + 0.016093001002445817 + ], + "loads_median": 0.032409969018772244, + "loads_min": 0.031935850012814626, + "loads_number": 200000, + "loads_runs": [ + 0.03651491799973883, + 0.032649774017045274, + 0.03265319697675295, + 0.032061068020993844, + 0.031935850012814626, + 0.032054716983111575, + 0.03253616800066084, + 0.032555878977291286, + 0.032409969018772244, + 0.03202212700853124, + 0.032126392994541675 + ] + } +} diff --git a/Misc/marshal-perf-data/exp7-run1.json b/Misc/marshal-perf-data/exp7-run1.json new file mode 100644 index 00000000000000..cd6a5a623a72b6 --- /dev/null +++ b/Misc/marshal-perf-data/exp7-run1.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.04053862899309024, + "dumps_min": 0.04010596399893984, + "dumps_number": 100000, + "dumps_runs": [ + 0.04063614900223911, + 0.04047581501072273, + 0.04053862899309024, + 0.040650468989042565, + 0.04010596399893984, + 0.04027075399062596, + 0.040578222018666565, + 0.040320976986549795, + 0.04071084997849539, + 0.04045198002131656, + 0.040724547987338156 + ], + "loads_median": 0.09603213600348681, + "loads_min": 0.09481743798824027, + "loads_number": 200000, + "loads_runs": [ + 0.09606517999782227, + 0.09603213600348681, + 0.0952294860035181, + 0.09481743798824027, + 0.09562255599303171, + 0.09789740099222399, + 0.0978437909798231, + 0.09785760898375884, + 0.09794873200007714, + 0.09598617698065937, + 0.09498928498942405 + ] + }, + "nested_dict": { + "dumps_median": 0.07698425799026154, + "dumps_min": 0.07556841199402697, + "dumps_number": 100000, + "dumps_runs": [ + 0.07778249098919332, + 0.075854441995034, + 0.07609889798914082, + 0.07556841199402697, + 0.07576207799138501, + 0.07714371100883, + 0.07698425799026154, + 0.07574128900887445, + 0.07701214999542572, + 0.07750482700066641, + 0.07724453299306333 + ], + "loads_median": 0.08417782100150362, + "loads_min": 0.08288180897943676, + "loads_number": 200000, + "loads_runs": [ + 0.08496690198080614, + 0.08355448700604029, + 0.08437801199033856, + 0.08417782100150362, + 0.0833600560144987, + 0.08493313798680902, + 0.08490349299972877, + 0.08517689400468953, + 0.08378304401412606, + 0.08403795299818739, + 0.08288180897943676 + ] + }, + "small_tuple": { + "dumps_median": 0.015638454002328217, + "dumps_min": 0.015519581997068599, + "dumps_number": 100000, + "dumps_runs": [ + 0.015676654991693795, + 0.01581074800924398, + 0.015674855996621773, + 0.015617808006936684, + 0.015519581997068599, + 0.015724353026598692, + 0.01563169399742037, + 0.015638454002328217, + 0.015607775014359504, + 0.015582190011627972, + 0.015740352013381198 + ], + "loads_median": 0.032573872013017535, + "loads_min": 0.03138695697998628, + "loads_number": 200000, + "loads_runs": [ + 0.033495409006718546, + 0.03614567199838348, + 0.03138695697998628, + 0.031880412017926574, + 0.032308911002473906, + 0.03261229899362661, + 0.032691925996914506, + 0.03283192700473592, + 0.032573872013017535, + 0.032100779993925244, + 0.03163518902147189 + ] + } +} diff --git a/Misc/marshal-perf-data/exp7-run2.json b/Misc/marshal-perf-data/exp7-run2.json new file mode 100644 index 00000000000000..bd82082cd06cb7 --- /dev/null +++ b/Misc/marshal-perf-data/exp7-run2.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.04039902598015033, + "dumps_min": 0.039823683007853106, + "dumps_number": 100000, + "dumps_runs": [ + 0.04077883600257337, + 0.04034962898003869, + 0.04026351700304076, + 0.04028936897520907, + 0.04104520799592137, + 0.039823683007853106, + 0.04073167001479305, + 0.040509638987714425, + 0.04039902598015033, + 0.04087140198680572, + 0.040387165994616225 + ], + "loads_median": 0.09717982201254927, + "loads_min": 0.09603104399866425, + "loads_number": 200000, + "loads_runs": [ + 0.09754744998645037, + 0.09603104399866425, + 0.09767279899097048, + 0.09683070701430552, + 0.09717982201254927, + 0.09776914701797068, + 0.0973580360005144, + 0.09741768901585601, + 0.09683061999385245, + 0.09618170099565759, + 0.09658296802081168 + ] + }, + "nested_dict": { + "dumps_median": 0.07718651602044702, + "dumps_min": 0.07510298301349394, + "dumps_number": 100000, + "dumps_runs": [ + 0.07685500700608827, + 0.07510298301349394, + 0.07546061300672591, + 0.07607325099525042, + 0.07610671201837249, + 0.07718651602044702, + 0.07749087398406118, + 0.07726633400307037, + 0.07797352902707644, + 0.077466969989473, + 0.07755574901239015 + ], + "loads_median": 0.08396684500621632, + "loads_min": 0.08257210601004772, + "loads_number": 200000, + "loads_runs": [ + 0.08396684500621632, + 0.08369886400760151, + 0.0834841750038322, + 0.08303174198954366, + 0.08406616197316907, + 0.08460984597331844, + 0.08346174997859634, + 0.08486542498576455, + 0.08441904600476846, + 0.0842588460072875, + 0.08257210601004772 + ] + }, + "small_tuple": { + "dumps_median": 0.015577055019093677, + "dumps_min": 0.015392407978652045, + "dumps_number": 100000, + "dumps_runs": [ + 0.015725502016721293, + 0.015508543991018087, + 0.015487482975004241, + 0.015392407978652045, + 0.015470566024305299, + 0.015709104016423225, + 0.01550992700504139, + 0.01570031698793173, + 0.015577055019093677, + 0.01570254800026305, + 0.015640830009942874 + ], + "loads_median": 0.03161492801154964, + "loads_min": 0.030888078006682917, + "loads_number": 200000, + "loads_runs": [ + 0.03314314701128751, + 0.03101835699635558, + 0.031102565000765026, + 0.030888078006682917, + 0.03133861199603416, + 0.0318103370082099, + 0.03214125899830833, + 0.031673589983256534, + 0.03215425100643188, + 0.03161492801154964, + 0.03139050101162866 + ] + } +} diff --git a/Misc/marshal-perf-data/exp7-run3.json b/Misc/marshal-perf-data/exp7-run3.json new file mode 100644 index 00000000000000..8916a7dcb41f13 --- /dev/null +++ b/Misc/marshal-perf-data/exp7-run3.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.040141895005945116, + "dumps_min": 0.039678489993093535, + "dumps_number": 100000, + "dumps_runs": [ + 0.03978781000478193, + 0.039678489993093535, + 0.03998674202011898, + 0.04088532901369035, + 0.04050860399729572, + 0.04015729800448753, + 0.040259442990645766, + 0.03987640998093411, + 0.040141895005945116, + 0.040711937996093184, + 0.039979260007385164 + ], + "loads_median": 0.09803275499143638, + "loads_min": 0.09656549501232803, + "loads_number": 200000, + "loads_runs": [ + 0.09656549501232803, + 0.09796579400426708, + 0.09858846900169738, + 0.09803275499143638, + 0.09680873199249618, + 0.09962924700812437, + 0.09945724598946981, + 0.09867175199906342, + 0.0998196690052282, + 0.09681351398467086, + 0.0970193579851184 + ] + }, + "nested_dict": { + "dumps_median": 0.07774702299502678, + "dumps_min": 0.07546453602844849, + "dumps_number": 100000, + "dumps_runs": [ + 0.07886188599513844, + 0.07592741900589317, + 0.07551086499006487, + 0.07608858900493942, + 0.07546453602844849, + 0.07755600902601145, + 0.07774702299502678, + 0.07799333799630404, + 0.07809473198722117, + 0.07855445498717017, + 0.07796995399985462 + ], + "loads_median": 0.08400226599769667, + "loads_min": 0.08291825500782579, + "loads_number": 200000, + "loads_runs": [ + 0.08383981400402263, + 0.08400226599769667, + 0.08353524497942999, + 0.08291825500782579, + 0.08365730597870424, + 0.08308543401653878, + 0.08461164697655477, + 0.08535803700215183, + 0.08569368699681945, + 0.08420007801032625, + 0.08475057600298896 + ] + }, + "small_tuple": { + "dumps_median": 0.015561328997137025, + "dumps_min": 0.015300511993700638, + "dumps_number": 100000, + "dumps_runs": [ + 0.0156345040013548, + 0.015349480003351346, + 0.015561328997137025, + 0.01564529098686762, + 0.015300511993700638, + 0.015374768991023302, + 0.015493339014938101, + 0.01543837200733833, + 0.01573513401672244, + 0.015706039004726335, + 0.01590597801259719 + ], + "loads_median": 0.03203163098078221, + "loads_min": 0.031719743012217805, + "loads_number": 200000, + "loads_runs": [ + 0.03377684799488634, + 0.031719743012217805, + 0.03179050999460742, + 0.03180401600548066, + 0.031864689983194694, + 0.032211068988544866, + 0.032372121000662446, + 0.03231633597170003, + 0.03232345500146039, + 0.03187895999872126, + 0.03203163098078221 + ] + } +} diff --git a/Misc/marshal-perf-data/exp8-run1.json b/Misc/marshal-perf-data/exp8-run1.json new file mode 100644 index 00000000000000..e69720657eb666 --- /dev/null +++ b/Misc/marshal-perf-data/exp8-run1.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.039757510006893426, + "dumps_min": 0.03944559700903483, + "dumps_number": 100000, + "dumps_runs": [ + 0.03997930302284658, + 0.0400872929894831, + 0.03947347402572632, + 0.03944559700903483, + 0.03950412000995129, + 0.040055121993646026, + 0.039469689974794164, + 0.039757510006893426, + 0.040212049992987886, + 0.03959803201723844, + 0.04053871598443948 + ], + "loads_median": 0.09801434801192954, + "loads_min": 0.09700208102003671, + "loads_number": 200000, + "loads_runs": [ + 0.09700208102003671, + 0.09775623999303207, + 0.09713842498604208, + 0.09773032600060105, + 0.09836526101571508, + 0.10028227002476342, + 0.09801434801192954, + 0.09911719398223795, + 0.09891376501764171, + 0.09701210999628529, + 0.09888661999139003 + ] + }, + "nested_dict": { + "dumps_median": 0.0774163989990484, + "dumps_min": 0.07508651999523863, + "dumps_number": 100000, + "dumps_runs": [ + 0.0774163989990484, + 0.075829982990399, + 0.07508651999523863, + 0.07588211400434375, + 0.08053561500855722, + 0.07738963200245053, + 0.07772310901782475, + 0.07800556599977426, + 0.07659625899395905, + 0.0818848900089506, + 0.07948859297903255 + ], + "loads_median": 0.08802441201987676, + "loads_min": 0.08570019001490436, + "loads_number": 200000, + "loads_runs": [ + 0.08721754100406542, + 0.08694913101498969, + 0.08822999798576348, + 0.08901180801331066, + 0.08813950698822737, + 0.08846079898648895, + 0.08570019001490436, + 0.08802441201987676, + 0.08841947399196215, + 0.08768736099591479, + 0.08707084899651818 + ] + }, + "small_tuple": { + "dumps_median": 0.015801069006556645, + "dumps_min": 0.01539811899419874, + "dumps_number": 100000, + "dumps_runs": [ + 0.016137794009409845, + 0.01548960799118504, + 0.01539811899419874, + 0.015473298990400508, + 0.015428863000124693, + 0.015678216994274408, + 0.015831777011044323, + 0.01592728600371629, + 0.015801069006556645, + 0.016072649013949558, + 0.01582824398064986 + ], + "loads_median": 0.03384080101386644, + "loads_min": 0.03279721798026003, + "loads_number": 200000, + "loads_runs": [ + 0.0381313799880445, + 0.03652328599127941, + 0.03362354700220749, + 0.03347562698763795, + 0.03279721798026003, + 0.03384080101386644, + 0.033389377000276, + 0.03447548899566755, + 0.03399212801014073, + 0.033593799016671255, + 0.03424841701053083 + ] + } +} diff --git a/Misc/marshal-perf-data/exp8-run2.json b/Misc/marshal-perf-data/exp8-run2.json new file mode 100644 index 00000000000000..4e163a9176c48a --- /dev/null +++ b/Misc/marshal-perf-data/exp8-run2.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.03977134401793592, + "dumps_min": 0.03928565501701087, + "dumps_number": 100000, + "dumps_runs": [ + 0.040546250995248556, + 0.03974068202660419, + 0.04057036500307731, + 0.03977134401793592, + 0.03928565501701087, + 0.03942169400397688, + 0.04005066698300652, + 0.040365419001318514, + 0.03979305498069152, + 0.03939504799200222, + 0.039724792004562914 + ], + "loads_median": 0.10045459101093002, + "loads_min": 0.09763487501186319, + "loads_number": 200000, + "loads_runs": [ + 0.10050111400778405, + 0.09763487501186319, + 0.0997635820240248, + 0.10045459101093002, + 0.09914230901631527, + 0.1009268619818613, + 0.10137583801406436, + 0.10085066300234757, + 0.10085751800215803, + 0.09830526800942607, + 0.10012540098978207 + ] + }, + "nested_dict": { + "dumps_median": 0.07501164599671029, + "dumps_min": 0.07376831700094044, + "dumps_number": 100000, + "dumps_runs": [ + 0.07693641999503598, + 0.07480335998116061, + 0.07376831700094044, + 0.07501164599671029, + 0.07480060699163005, + 0.07545904599828646, + 0.07610427599865943, + 0.07479583699023351, + 0.07653974700951949, + 0.07459977999678813, + 0.0755396590102464 + ], + "loads_median": 0.08776684699114412, + "loads_min": 0.08588809301727451, + "loads_number": 200000, + "loads_runs": [ + 0.08873178000794724, + 0.08824514999287203, + 0.08742920699296519, + 0.08750368902110495, + 0.08776684699114412, + 0.08832392300246283, + 0.08840812800917774, + 0.08588809301727451, + 0.08808830502675846, + 0.08716617300524376, + 0.08699598300154321 + ] + }, + "small_tuple": { + "dumps_median": 0.01589462801348418, + "dumps_min": 0.01562808800372295, + "dumps_number": 100000, + "dumps_runs": [ + 0.01591481702052988, + 0.015641414996935055, + 0.01575905899517238, + 0.01562808800372295, + 0.015793380996910855, + 0.015982561017153785, + 0.015966197999659926, + 0.016093573009129614, + 0.01580230999388732, + 0.0159107560175471, + 0.01589462801348418 + ], + "loads_median": 0.034105654020095244, + "loads_min": 0.033370910998201, + "loads_number": 200000, + "loads_runs": [ + 0.03540989899192937, + 0.03377522001392208, + 0.033370910998201, + 0.03361106201191433, + 0.03387770301196724, + 0.034416948998114094, + 0.03371126399724744, + 0.034105654020095244, + 0.03427084899158217, + 0.03427627799101174, + 0.034330024995142594 + ] + } +} diff --git a/Misc/marshal-perf-data/exp8-run3.json b/Misc/marshal-perf-data/exp8-run3.json new file mode 100644 index 00000000000000..b72bbf079f81dd --- /dev/null +++ b/Misc/marshal-perf-data/exp8-run3.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.03976497397525236, + "dumps_min": 0.0387425139779225, + "dumps_number": 100000, + "dumps_runs": [ + 0.039964331983355805, + 0.040582951973192394, + 0.03976497397525236, + 0.03908955299993977, + 0.0387425139779225, + 0.04000273300334811, + 0.03918595897266641, + 0.03962413698900491, + 0.040069857001071796, + 0.03929944400442764, + 0.040016515005845577 + ], + "loads_median": 0.09837035302189179, + "loads_min": 0.09705703897634521, + "loads_number": 200000, + "loads_runs": [ + 0.09705703897634521, + 0.09758267799043097, + 0.09757350399740972, + 0.0984837339783553, + 0.09837035302189179, + 0.09973495901795104, + 0.0989648760005366, + 0.10004294497775845, + 0.09837322498788126, + 0.09719676899840124, + 0.09749829498468898 + ] + }, + "nested_dict": { + "dumps_median": 0.07683631501276977, + "dumps_min": 0.07506426100735553, + "dumps_number": 100000, + "dumps_runs": [ + 0.07691431700368412, + 0.07506426100735553, + 0.07589571899734437, + 0.0753327060083393, + 0.0751879469898995, + 0.07683631501276977, + 0.07766320699010976, + 0.07763810700271279, + 0.07569738000165671, + 0.07762957399245352, + 0.07763727399287745 + ], + "loads_median": 0.08847640600288287, + "loads_min": 0.08711596598732285, + "loads_number": 200000, + "loads_runs": [ + 0.08849882299546152, + 0.08808554199640639, + 0.08711596598732285, + 0.08737207800731994, + 0.08847640600288287, + 0.11334325998905115, + 0.08920565599692054, + 0.08856613500392996, + 0.0890254330006428, + 0.08747486700303853, + 0.0878865139966365 + ] + }, + "small_tuple": { + "dumps_median": 0.015844114997889847, + "dumps_min": 0.015427826001541689, + "dumps_number": 100000, + "dumps_runs": [ + 0.015844114997889847, + 0.015501320012845099, + 0.015953151014400646, + 0.01558272200054489, + 0.015452104998985305, + 0.015427826001541689, + 0.015937362011754885, + 0.015592051000567153, + 0.015944652986945584, + 0.01643429501564242, + 0.016334432002622634 + ], + "loads_median": 0.03396754901041277, + "loads_min": 0.0333898350072559, + "loads_number": 200000, + "loads_runs": [ + 0.0356820389861241, + 0.03354457500972785, + 0.03365887000109069, + 0.03406547597842291, + 0.0333898350072559, + 0.03346274499199353, + 0.03447807699558325, + 0.033908181998413056, + 0.03398346499307081, + 0.03396754901041277, + 0.03403464797884226 + ] + } +} diff --git a/Misc/marshal-perf-data/exp9-run1.json b/Misc/marshal-perf-data/exp9-run1.json new file mode 100644 index 00000000000000..ea0a4e36cabeb1 --- /dev/null +++ b/Misc/marshal-perf-data/exp9-run1.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.036670544010121375, + "dumps_min": 0.036191349994624034, + "dumps_number": 100000, + "dumps_runs": [ + 0.036891941010253504, + 0.036670544010121375, + 0.03759862598963082, + 0.03656084599788301, + 0.03643028001533821, + 0.036191349994624034, + 0.03670074601541273, + 0.03684742099721916, + 0.03644928100402467, + 0.03684818299370818, + 0.03647110998281278 + ], + "loads_median": 0.09949431600398384, + "loads_min": 0.09780989700811915, + "loads_number": 200000, + "loads_runs": [ + 0.10030726401600987, + 0.0981906540109776, + 0.09912098798668012, + 0.09949431600398384, + 0.09887534700101241, + 0.10032743299962021, + 0.09988930201507173, + 0.10037328800535761, + 0.09967100698850118, + 0.09780989700811915, + 0.09798742202110589 + ] + }, + "nested_dict": { + "dumps_median": 0.07589465801720507, + "dumps_min": 0.07382799399783835, + "dumps_number": 100000, + "dumps_runs": [ + 0.07573907397454605, + 0.07426675700116903, + 0.0746230680088047, + 0.07382799399783835, + 0.07467629402526654, + 0.07679647800978273, + 0.07676106001599692, + 0.07638524498906918, + 0.07589465801720507, + 0.07751122998888604, + 0.0784091170062311 + ], + "loads_median": 0.08733567598392256, + "loads_min": 0.08589432400185615, + "loads_number": 200000, + "loads_runs": [ + 0.08655473400722258, + 0.08735713400528766, + 0.08671367197530344, + 0.08647687899065204, + 0.0868569909944199, + 0.08741487900260836, + 0.08813265099888667, + 0.0876804539875593, + 0.08768290601437911, + 0.08589432400185615, + 0.08733567598392256 + ] + }, + "small_tuple": { + "dumps_median": 0.01567695100675337, + "dumps_min": 0.01514164698892273, + "dumps_number": 100000, + "dumps_runs": [ + 0.015842837980017066, + 0.015273247001459822, + 0.015221432026010007, + 0.01514164698892273, + 0.015276604011887684, + 0.015439248003531247, + 0.01567695100675337, + 0.015833420009585097, + 0.01586761200451292, + 0.016118122002808377, + 0.016093090001959354 + ], + "loads_median": 0.03310302898171358, + "loads_min": 0.032207310025114566, + "loads_number": 200000, + "loads_runs": [ + 0.03679557499708608, + 0.034990312007721514, + 0.032762585004093125, + 0.032207310025114566, + 0.03237993799848482, + 0.032862921012565494, + 0.03331105597317219, + 0.033492589980596676, + 0.05221907299710438, + 0.03310302898171358, + 0.032766155985882506 + ] + } +} diff --git a/Misc/marshal-perf-data/exp9-run2.json b/Misc/marshal-perf-data/exp9-run2.json new file mode 100644 index 00000000000000..7153d816f065aa --- /dev/null +++ b/Misc/marshal-perf-data/exp9-run2.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.037413665995700285, + "dumps_min": 0.03698067902587354, + "dumps_number": 100000, + "dumps_runs": [ + 0.037936580018140376, + 0.037847008992685005, + 0.037250519992085174, + 0.03762381797423586, + 0.037413665995700285, + 0.03729245299473405, + 0.03748954500770196, + 0.03698870199150406, + 0.03698067902587354, + 0.037191545008681715, + 0.03795272600837052 + ], + "loads_median": 0.0988259740115609, + "loads_min": 0.097647748014424, + "loads_number": 200000, + "loads_runs": [ + 0.09900592901976779, + 0.0988259740115609, + 0.09795731998747215, + 0.09853494400158525, + 0.097647748014424, + 0.09997597898473032, + 0.09958649598411284, + 0.10050731000956148, + 0.09981053500087, + 0.09873375599272549, + 0.09802997700171545 + ] + }, + "nested_dict": { + "dumps_median": 0.07583290099864826, + "dumps_min": 0.07329990001744591, + "dumps_number": 100000, + "dumps_runs": [ + 0.07583290099864826, + 0.07404211297398433, + 0.0737786460085772, + 0.07361244701314718, + 0.07329990001744591, + 0.07616972498362884, + 0.07506408498738892, + 0.07633476599585265, + 0.07588039000984281, + 0.07665317298960872, + 0.07768141198903322 + ], + "loads_median": 0.08721121898270212, + "loads_min": 0.08669646800262854, + "loads_number": 200000, + "loads_runs": [ + 0.08756884199101478, + 0.08788898499915376, + 0.08721121898270212, + 0.08672690598177724, + 0.0867627379775513, + 0.08825624699238688, + 0.08669646800262854, + 0.08839206700213253, + 0.08853621798334643, + 0.08693327300716192, + 0.08717366401106119 + ] + }, + "small_tuple": { + "dumps_median": 0.015266494010575116, + "dumps_min": 0.014988107985118404, + "dumps_number": 100000, + "dumps_runs": [ + 0.015236178005579859, + 0.015176910994341597, + 0.01506905400310643, + 0.014988107985118404, + 0.015037344011943787, + 0.015506903000641614, + 0.015266494010575116, + 0.01569792500231415, + 0.015459520014701411, + 0.015411926986416802, + 0.015415769012179226 + ], + "loads_median": 0.03300381399458274, + "loads_min": 0.03263927000807598, + "loads_number": 200000, + "loads_runs": [ + 0.03494821998174302, + 0.03324511699611321, + 0.03271928598405793, + 0.03273383801570162, + 0.03263927000807598, + 0.033331290003843606, + 0.033301429997663945, + 0.03325751799275167, + 0.03300381399458274, + 0.032789846998639405, + 0.03283555299276486 + ] + } +} diff --git a/Misc/marshal-perf-data/exp9-run3.json b/Misc/marshal-perf-data/exp9-run3.json new file mode 100644 index 00000000000000..89347c2cc31a70 --- /dev/null +++ b/Misc/marshal-perf-data/exp9-run3.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.0372469819849357, + "dumps_min": 0.0367509420029819, + "dumps_number": 100000, + "dumps_runs": [ + 0.03777105800691061, + 0.03718775199376978, + 0.0372469819849357, + 0.03764093099744059, + 0.037644836003892124, + 0.03737743300735019, + 0.03697486702003516, + 0.03726457300945185, + 0.03678307600785047, + 0.036901844025123864, + 0.0367509420029819 + ], + "loads_median": 0.0980642469949089, + "loads_min": 0.09572154501802288, + "loads_number": 200000, + "loads_runs": [ + 0.09792753600049764, + 0.09853630600264296, + 0.09815591998631135, + 0.0980642469949089, + 0.09711574198445305, + 0.09723742000642233, + 0.09813128001405858, + 0.09910697597661056, + 0.09846785399713553, + 0.09661003699875437, + 0.09572154501802288 + ] + }, + "nested_dict": { + "dumps_median": 0.07589304799330421, + "dumps_min": 0.07428965700091794, + "dumps_number": 100000, + "dumps_runs": [ + 0.07626317697577178, + 0.07464601899846457, + 0.07445010700030252, + 0.07428965700091794, + 0.07442635198822245, + 0.07589304799330421, + 0.07596960398950614, + 0.0756447050080169, + 0.07701048100716434, + 0.077355098008411, + 0.07678630101145245 + ], + "loads_median": 0.08684102099505253, + "loads_min": 0.08553807099815458, + "loads_number": 200000, + "loads_runs": [ + 0.08762298998772167, + 0.0884358629991766, + 0.08775742698344402, + 0.08819824198144488, + 0.08684102099505253, + 0.08650777602451853, + 0.08675535500515252, + 0.08742336099385284, + 0.08599064202280715, + 0.08615379000548273, + 0.08553807099815458 + ] + }, + "small_tuple": { + "dumps_median": 0.015737580019049346, + "dumps_min": 0.015241361019434407, + "dumps_number": 100000, + "dumps_runs": [ + 0.01594545299303718, + 0.015786589996423572, + 0.015601074002915993, + 0.015753879997646436, + 0.015737580019049346, + 0.01558050699532032, + 0.015384086989797652, + 0.015400785981910303, + 0.015241361019434407, + 0.01598245301283896, + 0.016133682016516104 + ], + "loads_median": 0.03271479398244992, + "loads_min": 0.03236305501195602, + "loads_number": 200000, + "loads_runs": [ + 0.03297896301955916, + 0.03270359500311315, + 0.03271479398244992, + 0.03236305501195602, + 0.032802419998915866, + 0.033266873011598364, + 0.03299019898986444, + 0.0330110430077184, + 0.03240664899931289, + 0.03246427301201038, + 0.03248674297356047 + ] + } +} diff --git a/Misc/marshal-perf-data/expC-run1.json b/Misc/marshal-perf-data/expC-run1.json new file mode 100644 index 00000000000000..babe2189b2ce54 --- /dev/null +++ b/Misc/marshal-perf-data/expC-run1.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.03885153101873584, + "dumps_min": 0.03819433299941011, + "dumps_number": 100000, + "dumps_runs": [ + 0.03819433299941011, + 0.03885153101873584, + 0.039041784999426454, + 0.03869769399170764, + 0.038196515990421176, + 0.03835641100886278, + 0.039205601991852745, + 0.039084727002773434, + 0.03915372499614023, + 0.03840597398811951, + 0.03897938199224882 + ], + "loads_median": 0.08438826000201516, + "loads_min": 0.08349838099093176, + "loads_number": 200000, + "loads_runs": [ + 0.08451685099862516, + 0.08421161500154994, + 0.08391808700980619, + 0.08525156098767184, + 0.08349838099093176, + 0.08465198398334906, + 0.08548945101210847, + 0.08543380099581555, + 0.08438826000201516, + 0.08402247499907389, + 0.08381921300315298 + ] + }, + "nested_dict": { + "dumps_median": 0.07456793999881484, + "dumps_min": 0.07219768001232296, + "dumps_number": 100000, + "dumps_runs": [ + 0.07435124399489723, + 0.07264773099450395, + 0.07277951898868196, + 0.07219768001232296, + 0.07256349001545459, + 0.0749974139907863, + 0.07481357801589184, + 0.07456793999881484, + 0.07480899800430052, + 0.07585859700338915, + 0.07494700499228202 + ], + "loads_median": 0.07278906900319271, + "loads_min": 0.07237852000980638, + "loads_number": 200000, + "loads_runs": [ + 0.07270628900732845, + 0.07287266000639647, + 0.07278906900319271, + 0.07273351101321168, + 0.07237852000980638, + 0.07249393500387669, + 0.07257777100312524, + 0.07406299200374633, + 0.07333879300858825, + 0.09033372299745679, + 0.07319110399112105 + ] + }, + "small_tuple": { + "dumps_median": 0.015284862980479375, + "dumps_min": 0.014993085991591215, + "dumps_number": 100000, + "dumps_runs": [ + 0.015136354020796716, + 0.014993085991591215, + 0.01506140100536868, + 0.015356947988038883, + 0.015284862980479375, + 0.015400517993839458, + 0.015055116993607953, + 0.015131355001358315, + 0.015434630011441186, + 0.015335444011725485, + 0.015475683991098776 + ], + "loads_median": 0.02491334400838241, + "loads_min": 0.024755801976425573, + "loads_number": 200000, + "loads_runs": [ + 0.027463781007099897, + 0.027643058012472466, + 0.025008558994159102, + 0.02521929601789452, + 0.02483521099202335, + 0.024803680018521845, + 0.024781787011306733, + 0.024755801976425573, + 0.024782824999419972, + 0.02515164198121056, + 0.02491334400838241 + ] + } +} diff --git a/Misc/marshal-perf-data/expC-run2.json b/Misc/marshal-perf-data/expC-run2.json new file mode 100644 index 00000000000000..b813548ad0fedc --- /dev/null +++ b/Misc/marshal-perf-data/expC-run2.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.039398113993229344, + "dumps_min": 0.039030080020893365, + "dumps_number": 100000, + "dumps_runs": [ + 0.039030080020893365, + 0.039398113993229344, + 0.039818365999963135, + 0.04022960798465647, + 0.03926139700342901, + 0.03910875300061889, + 0.03919967598631047, + 0.04028505500173196, + 0.03944587698788382, + 0.0391325349919498, + 0.03953960500075482 + ], + "loads_median": 0.08406471399939619, + "loads_min": 0.08293949399376288, + "loads_number": 200000, + "loads_runs": [ + 0.08388902299338952, + 0.08308048700564541, + 0.08343190400046296, + 0.08406471399939619, + 0.08315308400779031, + 0.08414522599196061, + 0.08475377401919104, + 0.08481595502234995, + 0.08426703800796531, + 0.08293949399376288, + 0.08417479300987907 + ] + }, + "nested_dict": { + "dumps_median": 0.07434552800259553, + "dumps_min": 0.0731420659867581, + "dumps_number": 100000, + "dumps_runs": [ + 0.07531479001045227, + 0.07373224999173544, + 0.07370664898189716, + 0.07342061400413513, + 0.0731420659867581, + 0.07467770902439952, + 0.07503044398617931, + 0.07462426999700256, + 0.0738755020138342, + 0.07483597297687083, + 0.07434552800259553 + ], + "loads_median": 0.07250742800533772, + "loads_min": 0.07181784400017932, + "loads_number": 200000, + "loads_runs": [ + 0.07267852002405562, + 0.07230501002050005, + 0.07181784400017932, + 0.0720679480000399, + 0.07254380200174637, + 0.07212767499731854, + 0.07309033197816461, + 0.07232997700339183, + 0.07339794200379401, + 0.07339047201094218, + 0.07250742800533772 + ] + }, + "small_tuple": { + "dumps_median": 0.015363972983323038, + "dumps_min": 0.015148940001381561, + "dumps_number": 100000, + "dumps_runs": [ + 0.015368007007054985, + 0.015280455001629889, + 0.015282834006939083, + 0.015180368005530909, + 0.015148940001381561, + 0.01528518000850454, + 0.015394849004223943, + 0.015363972983323038, + 0.015438720991369337, + 0.015677611983846873, + 0.01578400598373264 + ], + "loads_median": 0.025077969999983907, + "loads_min": 0.024724956980207935, + "loads_number": 200000, + "loads_runs": [ + 0.027866761985933408, + 0.024864916020305827, + 0.025145669002085924, + 0.024889567983336747, + 0.02473973698215559, + 0.02473353999084793, + 0.025077969999983907, + 0.02516046800883487, + 0.025122569990344346, + 0.024724956980207935, + 0.02526067799772136 + ] + } +} diff --git a/Misc/marshal-perf-data/expC-run3.json b/Misc/marshal-perf-data/expC-run3.json new file mode 100644 index 00000000000000..466bd86a9cca6e --- /dev/null +++ b/Misc/marshal-perf-data/expC-run3.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.04002185200806707, + "dumps_min": 0.0393153729964979, + "dumps_number": 100000, + "dumps_runs": [ + 0.039719634980428964, + 0.040038525010459125, + 0.04026459399028681, + 0.0399914369918406, + 0.04002185200806707, + 0.03997190701193176, + 0.04004406699095853, + 0.04005959597998299, + 0.04008894000435248, + 0.039827683998737484, + 0.0393153729964979 + ], + "loads_median": 0.08476333800354041, + "loads_min": 0.08338961101253517, + "loads_number": 200000, + "loads_runs": [ + 0.08471398998517543, + 0.08490564400563017, + 0.08476333800354041, + 0.0852102309872862, + 0.08415983497980051, + 0.08602925698505715, + 0.08472812702530064, + 0.08507365500554442, + 0.08546493900939822, + 0.08371160997194238, + 0.08338961101253517 + ] + }, + "nested_dict": { + "dumps_median": 0.07240149099379778, + "dumps_min": 0.07175707098213024, + "dumps_number": 100000, + "dumps_runs": [ + 0.07202656200388446, + 0.07263909498578869, + 0.0723600119818002, + 0.07247643600567244, + 0.07203713100170717, + 0.07240149099379778, + 0.07175707098213024, + 0.07228745799511671, + 0.07331369401072152, + 0.07349270200938918, + 0.07281196699477732 + ], + "loads_median": 0.07257888998719864, + "loads_min": 0.07134022601530887, + "loads_number": 200000, + "loads_runs": [ + 0.07302617799723521, + 0.07272034001653083, + 0.07134022601530887, + 0.07235070600290783, + 0.07191561802756041, + 0.07305586399161257, + 0.07186922099208459, + 0.07216792899998836, + 0.07275046201539226, + 0.07257888998719864, + 0.0728685750218574 + ] + }, + "small_tuple": { + "dumps_median": 0.01515040302183479, + "dumps_min": 0.01495419500861317, + "dumps_number": 100000, + "dumps_runs": [ + 0.01515040302183479, + 0.01495419500861317, + 0.014996377984061837, + 0.015111985005205497, + 0.014983305998612195, + 0.015473948005819693, + 0.015253463992848992, + 0.015140636009164155, + 0.015470629004994407, + 0.015679892007028684, + 0.01540743699297309 + ], + "loads_median": 0.02486449701245874, + "loads_min": 0.02464576900820248, + "loads_number": 200000, + "loads_runs": [ + 0.028908314008731395, + 0.024992456019390374, + 0.024887868989026174, + 0.0246770610101521, + 0.02464576900820248, + 0.02486449701245874, + 0.024984908028272912, + 0.025076719000935555, + 0.02480522499536164, + 0.02484015200752765, + 0.024846042011631653 + ] + } +} diff --git a/Misc/marshal-perf-data/final-head-run1.json b/Misc/marshal-perf-data/final-head-run1.json new file mode 100644 index 00000000000000..5e1c74ca086e44 --- /dev/null +++ b/Misc/marshal-perf-data/final-head-run1.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.03861066699028015, + "dumps_min": 0.03829061400028877, + "dumps_number": 100000, + "dumps_runs": [ + 0.03861066699028015, + 0.03967850800836459, + 0.038798524998128414, + 0.038854629994602874, + 0.03829061400028877, + 0.03842497800360434, + 0.038555770996026695, + 0.03949232102604583, + 0.038440226984675974, + 0.038455867004813626, + 0.03890348697314039 + ], + "loads_median": 0.08477738598594442, + "loads_min": 0.08255283601465635, + "loads_number": 200000, + "loads_runs": [ + 0.08503403802751563, + 0.08559962498839013, + 0.08436413499293849, + 0.0859253219969105, + 0.08392031298717484, + 0.08477738598594442, + 0.08420120298978873, + 0.08518156799254939, + 0.08608373699826188, + 0.08255283601465635, + 0.08303554999292828 + ] + }, + "nested_dict": { + "dumps_median": 0.07384449598612264, + "dumps_min": 0.07236154898419045, + "dumps_number": 100000, + "dumps_runs": [ + 0.0748500149929896, + 0.07236154898419045, + 0.07243166700936854, + 0.07274906800012104, + 0.07299651400535367, + 0.07551556499674916, + 0.07513869399554096, + 0.07384449598612264, + 0.07346348999999464, + 0.07528829498915002, + 0.07485370599897578 + ], + "loads_median": 0.07287541500409134, + "loads_min": 0.07209090801188722, + "loads_number": 200000, + "loads_runs": [ + 0.07254791000741534, + 0.0735983659978956, + 0.07354093200410716, + 0.07264083798509091, + 0.0727318059944082, + 0.07349560898728669, + 0.07336675401893444, + 0.07325002702418715, + 0.07287541500409134, + 0.07209090801188722, + 0.07235794598818757 + ] + }, + "small_tuple": { + "dumps_median": 0.015514081984292716, + "dumps_min": 0.015210407989798114, + "dumps_number": 100000, + "dumps_runs": [ + 0.015748438017908484, + 0.015413881017593667, + 0.01548922000802122, + 0.015210407989798114, + 0.015520148997893557, + 0.015505564020713791, + 0.015538184001343325, + 0.015562913991743699, + 0.015378834010334685, + 0.015558833023533225, + 0.015514081984292716 + ], + "loads_median": 0.02537923600175418, + "loads_min": 0.024743166024563834, + "loads_number": 200000, + "loads_runs": [ + 0.028921025979798287, + 0.029282872012117878, + 0.027216265007155016, + 0.024975700012873858, + 0.02477260900195688, + 0.024743166024563834, + 0.025470549997407943, + 0.02537923600175418, + 0.025482377008302137, + 0.02500459799193777, + 0.025150754023343325 + ] + } +} diff --git a/Misc/marshal-perf-data/final-head-run2.json b/Misc/marshal-perf-data/final-head-run2.json new file mode 100644 index 00000000000000..ffc67dafc819ad --- /dev/null +++ b/Misc/marshal-perf-data/final-head-run2.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.03859975902014412, + "dumps_min": 0.038358157995389774, + "dumps_number": 100000, + "dumps_runs": [ + 0.03859975902014412, + 0.038815806998172775, + 0.038651545997709036, + 0.038386632018955424, + 0.03850956799578853, + 0.038758448004955426, + 0.038876492995768785, + 0.038358157995389774, + 0.038583580986596644, + 0.03875641000922769, + 0.03842518600868061 + ], + "loads_median": 0.08391545098857023, + "loads_min": 0.08281204800005071, + "loads_number": 200000, + "loads_runs": [ + 0.08391545098857023, + 0.08365646499441937, + 0.0844366009987425, + 0.08418649900704622, + 0.08281204800005071, + 0.08422902200254612, + 0.08417390199610963, + 0.08386583102401346, + 0.08468431601068005, + 0.08358922399929725, + 0.08288625499699265 + ] + }, + "nested_dict": { + "dumps_median": 0.07224969199160114, + "dumps_min": 0.07175821100827307, + "dumps_number": 100000, + "dumps_runs": [ + 0.0722330319986213, + 0.07224969199160114, + 0.07175821100827307, + 0.07191025698557496, + 0.07206307299202308, + 0.07199287001276389, + 0.0730549760046415, + 0.0728809580032248, + 0.07331392998457886, + 0.07316177600296214, + 0.07256767700891942 + ], + "loads_median": 0.07226478302618489, + "loads_min": 0.07167983998078853, + "loads_number": 200000, + "loads_runs": [ + 0.07247319398447871, + 0.07285689198761247, + 0.07201626701862551, + 0.07167983998078853, + 0.07208228798117489, + 0.07226478302618489, + 0.07262303499737754, + 0.07189797502360307, + 0.07263053100905381, + 0.07221274598850869, + 0.07237509498372674 + ] + }, + "small_tuple": { + "dumps_median": 0.015210209996439517, + "dumps_min": 0.015028170018922538, + "dumps_number": 100000, + "dumps_runs": [ + 0.015210209996439517, + 0.015356637013610452, + 0.015085900988196954, + 0.015028170018922538, + 0.015100438991794363, + 0.015315671014832333, + 0.015176904998952523, + 0.015208769007585943, + 0.015245105023495853, + 0.015349433990195394, + 0.015317495010094717 + ], + "loads_median": 0.025087059009820223, + "loads_min": 0.024549460998969153, + "loads_number": 200000, + "loads_runs": [ + 0.027895082981558517, + 0.024630763015011325, + 0.02456256898585707, + 0.024549460998969153, + 0.025087059009820223, + 0.024739325017435476, + 0.025273887993535027, + 0.024848716013366356, + 0.025249957019696012, + 0.025194219982950017, + 0.025204714009305462 + ] + } +} diff --git a/Misc/marshal-perf-data/final-head-run3.json b/Misc/marshal-perf-data/final-head-run3.json new file mode 100644 index 00000000000000..6205522713ddd8 --- /dev/null +++ b/Misc/marshal-perf-data/final-head-run3.json @@ -0,0 +1,104 @@ +{ + "code_obj": { + "dumps_median": 0.039093311002943665, + "dumps_min": 0.03853208900545724, + "dumps_number": 100000, + "dumps_runs": [ + 0.03952263301471248, + 0.03853208900545724, + 0.038702839985489845, + 0.039093311002943665, + 0.03952905800542794, + 0.03962709600455128, + 0.03873331900103949, + 0.03890918698743917, + 0.03953164297854528, + 0.03972663599415682, + 0.03893458898528479 + ], + "loads_median": 0.08579147097771056, + "loads_min": 0.08457510100561194, + "loads_number": 200000, + "loads_runs": [ + 0.08571545200538822, + 0.08613795001292601, + 0.08466976502677426, + 0.08457510100561194, + 0.08579147097771056, + 0.08606167297693901, + 0.08608556500985287, + 0.08607279698480852, + 0.08584638198954053, + 0.08539813201059587, + 0.08552845497615635 + ] + }, + "nested_dict": { + "dumps_median": 0.0733790369995404, + "dumps_min": 0.0721345600031782, + "dumps_number": 100000, + "dumps_runs": [ + 0.0737456209899392, + 0.07272098498651758, + 0.07229295599972829, + 0.07266653899569064, + 0.07491926298826002, + 0.07343927401234396, + 0.07353530899854377, + 0.0721345600031782, + 0.07287592100328766, + 0.07443445900571533, + 0.0733790369995404 + ], + "loads_median": 0.07214623902109452, + "loads_min": 0.0714967749954667, + "loads_number": 200000, + "loads_runs": [ + 0.07255928797530942, + 0.0722025019931607, + 0.07204260601429269, + 0.0714967749954667, + 0.07185451500117779, + 0.07151597301708534, + 0.07214623902109452, + 0.07251594401896, + 0.0718693759990856, + 0.07297698201728053, + 0.07265513599850237 + ] + }, + "small_tuple": { + "dumps_median": 0.015372966998256743, + "dumps_min": 0.015162347990553826, + "dumps_number": 100000, + "dumps_runs": [ + 0.015432773012435064, + 0.015204997995169833, + 0.015162347990553826, + 0.015323817991884425, + 0.01556495000841096, + 0.015372966998256743, + 0.015252572018653154, + 0.015533694997429848, + 0.015234314982080832, + 0.015478985995287076, + 0.015435008011991158 + ], + "loads_median": 0.024819322978146374, + "loads_min": 0.024503789987647906, + "loads_number": 200000, + "loads_runs": [ + 0.02666928799590096, + 0.02475421500275843, + 0.024842896993504837, + 0.024819322978146374, + 0.024503789987647906, + 0.024549788009608164, + 0.024721760011743754, + 0.024588766013039276, + 0.024928136001108214, + 0.024914915004046634, + 0.025074609991861507 + ] + } +} diff --git a/Misc/marshal-perf-data/pyperf-slice-baseline.json b/Misc/marshal-perf-data/pyperf-slice-baseline.json new file mode 100644 index 00000000000000..93d1a0ec8873b3 --- /dev/null +++ b/Misc/marshal-perf-data/pyperf-slice-baseline.json @@ -0,0 +1 @@ +{"benchmarks":[{"metadata":{"description":"Test the performance of pickling.","inner_loops":20,"loops":1024,"name":"pickle","pickle_module":"pickle","pickle_protocol":"5","python_cflags":"-fno-strict-overflow -Wsign-compare -DNDEBUG -g -O3 -Wall","python_compiler":"GCC 15.2.0","python_config_args":"'--prefix=/tmp/cpython-build-baseline'","python_executable":"/home/mjbommar/src/cpython/venv/cpython3.15-97bec89492cb-compat-31b33d68c68a/bin/python","python_implementation":"cpython","python_version":"3.15.0a8+ (64-bit) revision 2faceeec5c0","tags":["serialize"],"timer":"clock_gettime(CLOCK_MONOTONIC), resolution: 1.00 ns"},"runs":[{"metadata":{"calibrate_loops":1024,"cpu_freq":"0=4892 MHz","cpu_temp":"coretemp:Package id 0=59 C, coretemp:Core 0=59 C","date":"2026-04-17 14:40:07.172109","duration":0.7841060660139192,"load_avg_1min":3.66,"mem_max_rss":24862720,"runnable_threads":3,"uptime":202361.17897439003},"warmups":[[1,8.870750025380403e-06],[2,7.30105020920746e-06],[4,7.344625191763043e-06],[8,7.201131120382343e-06],[16,7.1680468863633e-06],[32,7.403857853205409e-06],[64,7.284446110134013e-06],[128,7.330400001137604e-06],[256,7.314328126994951e-06],[512,7.246968456797731e-06],[1024,7.240924364282364e-06],[1024,7.28010644479582e-06],[1024,7.229342236314551e-06],[1024,8.478622949326108e-06]]},{"metadata":{"cpu_freq":"0=5085 MHz","cpu_temp":"coretemp:Package id 0=59 C, coretemp:Core 0=59 C","date":"2026-04-17 14:40:07.824339","duration":0.5832422340172343,"load_avg_1min":3.52,"mem_max_rss":25059328,"runnable_threads":2,"uptime":202361.82612276077},"values":[6.906046044719005e-06,6.950431786378886e-06,7.0512663569388675e-06],"warmups":[[1024,7.058104833390643e-06]]},{"metadata":{"cpu_freq":"0=5082 MHz","cpu_temp":"coretemp:Package id 0=68 C, coretemp:Core 0=68 C","date":"2026-04-17 14:40:08.500437","duration":0.6141629880003165,"load_avg_1min":3.52,"mem_max_rss":25059328,"runnable_threads":2,"uptime":202362.50223374367},"values":[7.175548290661027e-06,7.52521347635593e-06,7.436613428524197e-06],"warmups":[[1024,7.32894248045568e-06]]},{"metadata":{"cpu_freq":"0=5065 MHz","cpu_temp":"coretemp:Package id 0=68 C, coretemp:Core 0=68 C","date":"2026-04-17 14:40:09.164156","duration":0.6024247460009065,"load_avg_1min":3.52,"mem_max_rss":25059328,"runnable_threads":1,"uptime":202363.1660311222},"values":[7.250427587734976e-06,7.2302482905683975e-06,7.230149267911656e-06],"warmups":[[1024,7.185985352009538e-06]]},{"metadata":{"cpu_freq":"0=5084 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:40:09.809933","duration":0.5841261770110577,"load_avg_1min":3.52,"mem_max_rss":25059328,"runnable_threads":1,"uptime":202363.81174850464},"values":[7.044284375012922e-06,6.959515430082774e-06,7.008702294797331e-06],"warmups":[[1024,6.997732812408231e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:40:10.475372","duration":0.6034721419855487,"load_avg_1min":3.52,"mem_max_rss":25059328,"runnable_threads":3,"uptime":202364.47716665268},"values":[7.193751220313516e-06,7.197917089740713e-06,7.282459472435221e-06],"warmups":[[1024,7.273175340571924e-06]]},{"metadata":{"cpu_freq":"0=5044 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:40:11.131540","duration":0.5932048539980315,"load_avg_1min":3.52,"mem_max_rss":25059328,"runnable_threads":2,"uptime":202365.13330960274},"values":[7.085546874918691e-06,7.111905858891987e-06,7.107072850942586e-06],"warmups":[[1024,7.142391895342826e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:40:11.780164","duration":0.5887481879908592,"load_avg_1min":3.52,"mem_max_rss":25059328,"runnable_threads":1,"uptime":202365.78191518784},"values":[7.048729686687239e-06,7.053806346846159e-06,7.1004854973466536e-06],"warmups":[[1024,7.038266993220077e-06]]},{"metadata":{"cpu_freq":"0=5062 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:12.435305","duration":0.5931854009977542,"load_avg_1min":3.52,"mem_max_rss":25059328,"runnable_threads":1,"uptime":202366.43711161613},"values":[7.088279198796954e-06,7.073098583987303e-06,7.100977197183056e-06],"warmups":[[1024,7.189776415827964e-06]]},{"metadata":{"cpu_freq":"0=5082 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:13.087253","duration":0.5909115849935915,"load_avg_1min":3.48,"mem_max_rss":25059328,"runnable_threads":1,"uptime":202367.0889084339},"values":[7.03610498078433e-06,7.075067919970479e-06,7.161819043233209e-06],"warmups":[[1024,7.070680467791135e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=75 C, coretemp:Core 0=75 C","date":"2026-04-17 14:40:13.735722","duration":0.5861230399750639,"load_avg_1min":3.48,"mem_max_rss":25059328,"runnable_threads":1,"uptime":202367.737541914},"values":[7.0223015626424966e-06,7.042671923329635e-06,7.0001832526145336e-06],"warmups":[[1024,7.010097802151449e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=75 C, coretemp:Core 0=75 C","date":"2026-04-17 14:40:14.396793","duration":0.5988711779937148,"load_avg_1min":3.48,"mem_max_rss":25059328,"runnable_threads":2,"uptime":202368.39859342575},"values":[7.152900145968033e-06,7.28677275390055e-06,7.138100878023579e-06],"warmups":[[1024,7.1466601070824256e-06]]},{"metadata":{"cpu_freq":"0=4934 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:15.045941","duration":0.5886794720136095,"load_avg_1min":3.48,"mem_max_rss":25059328,"runnable_threads":6,"uptime":202369.04773020744},"values":[7.069512989232862e-06,7.0222478527171004e-06,7.044746192264029e-06],"warmups":[[1024,7.073759863374107e-06]]},{"metadata":{"cpu_freq":"0=5043 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:15.693222","duration":0.5851445059815887,"load_avg_1min":3.48,"mem_max_rss":25059328,"runnable_threads":1,"uptime":202369.69500231743},"values":[7.147282128983079e-06,6.946241016692057e-06,7.004731004656151e-06],"warmups":[[1024,6.953465089054589e-06]]},{"metadata":{"cpu_freq":"0=4990 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:40:16.347758","duration":0.5926007829839364,"load_avg_1min":3.48,"mem_max_rss":25059328,"runnable_threads":2,"uptime":202370.34958219528},"values":[7.137169140492005e-06,7.079556836231404e-06,7.114820019182844e-06],"warmups":[[1024,7.089386522807218e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:40:16.996864","duration":0.5891454939846881,"load_avg_1min":3.48,"mem_max_rss":25059328,"runnable_threads":2,"uptime":202370.99871897697},"values":[7.053775976828547e-06,7.128433837522153e-06,7.060138720760278e-06],"warmups":[[1024,6.990457080746637e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=78 C, coretemp:Core 0=78 C","date":"2026-04-17 14:40:17.646546","duration":0.585920969984727,"load_avg_1min":3.28,"mem_max_rss":25059328,"runnable_threads":1,"uptime":202371.6483259201},"values":[7.017662744601693e-06,7.014075781341944e-06,7.039912402717618e-06],"warmups":[[1024,7.033028174419087e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=78 C, coretemp:Core 0=78 C","date":"2026-04-17 14:40:18.297418","duration":0.5902096680074465,"load_avg_1min":3.28,"mem_max_rss":25059328,"runnable_threads":1,"uptime":202372.29920434952},"values":[7.063248193617255e-06,7.110259765852334e-06,7.105773681814753e-06],"warmups":[[1024,7.028017186883062e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:18.952309","duration":0.5929401089961175,"load_avg_1min":3.28,"mem_max_rss":25059328,"runnable_threads":2,"uptime":202372.95419597626},"values":[7.11008847673611e-06,7.166412402170863e-06,7.084398242795942e-06],"warmups":[[1024,7.059810155851665e-06]]},{"metadata":{"cpu_freq":"0=5026 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:19.743496","duration":0.7295771530189086,"load_avg_1min":3.28,"mem_max_rss":25059328,"runnable_threads":2,"uptime":202373.74526953697},"values":[8.749407616903681e-06,8.746954686955633e-06,8.815873779610684e-06],"warmups":[[1024,8.801478905695603e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=62 C, coretemp:Core 0=62 C","date":"2026-04-17 14:40:20.390788","duration":0.5867273479816504,"load_avg_1min":3.28,"mem_max_rss":25059328,"runnable_threads":1,"uptime":202374.39255809784},"values":[7.060080126564117e-06,7.004028759638459e-06,7.10388354434599e-06],"warmups":[[1024,6.971082373752324e-06]]}]},{"metadata":{"description":"Test the performance of pickling.","inner_loops":5,"loops":2048,"name":"pickle_dict","pickle_module":"pickle","pickle_protocol":"5","python_cflags":"-fno-strict-overflow -Wsign-compare -DNDEBUG -g -O3 -Wall","python_compiler":"GCC 15.2.0","python_config_args":"'--prefix=/tmp/cpython-build-baseline'","python_executable":"/home/mjbommar/src/cpython/venv/cpython3.15-97bec89492cb-compat-31b33d68c68a/bin/python","python_implementation":"cpython","python_version":"3.15.0a8+ (64-bit) revision 2faceeec5c0","tags":["serialize"],"timer":"clock_gettime(CLOCK_MONOTONIC), resolution: 1.00 ns"},"runs":[{"metadata":{"calibrate_loops":2048,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=62 C, coretemp:Core 0=62 C","date":"2026-04-17 14:40:21.369110","duration":0.8535998830047902,"load_avg_1min":3.28,"mem_max_rss":24817664,"runnable_threads":2,"uptime":202375.37092852592},"warmups":[[1,1.797760487534106e-05],[2,1.7141699208877982e-05],[4,1.7262500477954745e-05],[8,1.6790900554042308e-05],[16,1.6640624744468367e-05],[32,1.61998375915573e-05],[64,1.6424499972345074e-05],[128,1.6349348425137577e-05],[256,1.624804140192282e-05],[512,1.645878007821011e-05],[1024,1.6522259375051363e-05],[2048,1.6404502829914236e-05],[2048,1.650744882795152e-05],[2048,1.6413615040278273e-05],[2048,1.6523751659747178e-05]]},{"metadata":{"cpu_freq":"0=4950 MHz","cpu_temp":"coretemp:Package id 0=77 C, coretemp:Core 0=77 C","date":"2026-04-17 14:40:22.126558","duration":0.6951366889989004,"load_avg_1min":3.28,"mem_max_rss":24850432,"runnable_threads":2,"uptime":202376.1283814907},"values":[1.670923076346753e-05,1.67306087888619e-05,1.673323818351946e-05],"warmups":[[2048,1.6673910252507085e-05]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=70 C","date":"2026-04-17 14:40:22.864374","duration":0.6767241729830857,"load_avg_1min":3.1,"mem_max_rss":24961024,"runnable_threads":1,"uptime":202376.86617565155},"values":[1.6187429784508824e-05,1.6274217480827245e-05,1.6247370115252125e-05],"warmups":[[2048,1.6342758985388173e-05]]},{"metadata":{"cpu_freq":"0=4918 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=70 C","date":"2026-04-17 14:40:23.609570","duration":0.6836254750087392,"load_avg_1min":3.1,"mem_max_rss":25014272,"runnable_threads":3,"uptime":202377.6113872528},"values":[1.6375175292182576e-05,1.6433712792718326e-05,1.645148359443738e-05],"warmups":[[2048,1.645367656237795e-05]]},{"metadata":{"cpu_freq":"0=5081 MHz","cpu_temp":"coretemp:Package id 0=71 C, coretemp:Core 0=66 C","date":"2026-04-17 14:40:24.356246","duration":0.6855964940041304,"load_avg_1min":3.1,"mem_max_rss":25124864,"runnable_threads":2,"uptime":202378.35804605484},"values":[1.6386269825829915e-05,1.6477954295623932e-05,1.661291709069701e-05],"warmups":[[2048,1.644377607306069e-05]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=71 C, coretemp:Core 0=66 C","date":"2026-04-17 14:40:25.106164","duration":0.6882047629915178,"load_avg_1min":3.1,"mem_max_rss":24850432,"runnable_threads":1,"uptime":202379.10789513588},"values":[1.6554067579477304e-05,1.657150312439626e-05,1.6533837109022897e-05],"warmups":[[2048,1.6522957324127674e-05]]},{"metadata":{"cpu_freq":"0=5036 MHz","cpu_temp":"coretemp:Package id 0=77 C, coretemp:Core 0=77 C","date":"2026-04-17 14:40:25.852669","duration":0.6861345390207134,"load_avg_1min":3.1,"mem_max_rss":24993792,"runnable_threads":1,"uptime":202379.8544676304},"values":[1.6601587790887607e-05,1.6386953808478212e-05,1.6535760352098805e-05],"warmups":[[2048,1.6448862695028765e-05]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:40:26.606152","duration":0.6917419290111866,"load_avg_1min":3.1,"mem_max_rss":24850432,"runnable_threads":3,"uptime":202380.60797929764},"values":[1.6556377050847005e-05,1.6604442674861274e-05,1.6499796876701113e-05],"warmups":[[2048,1.6852257127197844e-05]]},{"metadata":{"cpu_freq":"0=5065 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:40:27.350099","duration":0.6833598469966091,"load_avg_1min":3.1,"mem_max_rss":24879104,"runnable_threads":1,"uptime":202381.3519194126},"values":[1.6499075391607222e-05,1.63346236348616e-05,1.6259230079640474e-05],"warmups":[[2048,1.6627583886474894e-05]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:40:28.089786","duration":0.6793474230216816,"load_avg_1min":2.93,"mem_max_rss":24907776,"runnable_threads":1,"uptime":202382.09140515327},"values":[1.644317402451634e-05,1.6246558888610708e-05,1.6386651174116197e-05],"warmups":[[2048,1.6240188867300275e-05]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:40:28.825431","duration":0.6752949270012323,"load_avg_1min":2.93,"mem_max_rss":24870912,"runnable_threads":2,"uptime":202382.8272755146},"values":[1.614457773371214e-05,1.625705419883161e-05,1.6264047459912945e-05],"warmups":[[2048,1.6253852345471385e-05]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=78 C, coretemp:Core 0=78 C","date":"2026-04-17 14:40:29.571921","duration":0.6863474120036699,"load_avg_1min":2.93,"mem_max_rss":24850432,"runnable_threads":3,"uptime":202383.5737364292},"values":[1.6492618749452957e-05,1.665449521510709e-05,1.637586601361818e-05],"warmups":[[2048,1.6455401268444803e-05]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=78 C, coretemp:Core 0=78 C","date":"2026-04-17 14:40:30.308325","duration":0.674693260982167,"load_avg_1min":2.93,"mem_max_rss":24850432,"runnable_threads":1,"uptime":202384.31018781662},"values":[1.6197080373103746e-05,1.6215267871189097e-05,1.620578525489691e-05],"warmups":[[2048,1.6246658788077184e-05]]},{"metadata":{"cpu_freq":"0=5027 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:40:31.050344","duration":0.6815198410185985,"load_avg_1min":2.93,"mem_max_rss":24973312,"runnable_threads":5,"uptime":202385.0520181656},"values":[1.6373488963949968e-05,1.6449262304263357e-05,1.6335124999500295e-05],"warmups":[[2048,1.635866396441088e-05]]},{"metadata":{"cpu_freq":"0=5026 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:40:31.807109","duration":0.6929243459890131,"load_avg_1min":2.93,"mem_max_rss":24850432,"runnable_threads":2,"uptime":202385.8089015484},"values":[1.780319902309202e-05,1.6259476561231166e-05,1.617831406406367e-05],"warmups":[[2048,1.6375749120811632e-05]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:40:32.551043","duration":0.6829923320037778,"load_avg_1min":2.86,"mem_max_rss":24850432,"runnable_threads":1,"uptime":202386.55282187462},"values":[1.643327529166072e-05,1.6542954199394444e-05,1.629228623016843e-05],"warmups":[[2048,1.6389253028137317e-05]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:40:33.294771","duration":0.6826022109889891,"load_avg_1min":2.86,"mem_max_rss":24862720,"runnable_threads":2,"uptime":202387.29662418365},"values":[1.6309993065988236e-05,1.6418132324247382e-05,1.6551482030990882e-05],"warmups":[[2048,1.6307352927924514e-05]]},{"metadata":{"cpu_freq":"0=4923 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:34.043734","duration":0.6866314109938685,"load_avg_1min":2.86,"mem_max_rss":24977408,"runnable_threads":7,"uptime":202388.04546952248},"values":[1.6543955763381745e-05,1.652183535156837e-05,1.6388995507554683e-05],"warmups":[[2048,1.6535614940949016e-05]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:34.792554","duration":0.6864091710012872,"load_avg_1min":2.86,"mem_max_rss":24850432,"runnable_threads":2,"uptime":202388.79437685013},"values":[1.639884540907133e-05,1.6483220215945947e-05,1.660600244122179e-05],"warmups":[[2048,1.6503783007237872e-05]]},{"metadata":{"cpu_freq":"0=5080 MHz","cpu_temp":"coretemp:Package id 0=82 C, coretemp:Core 0=82 C","date":"2026-04-17 14:40:35.536586","duration":0.6827514350006822,"load_avg_1min":2.86,"mem_max_rss":24973312,"runnable_threads":1,"uptime":202389.53833150864},"values":[1.6348194043303012e-05,1.6383145896270436e-05,1.6474976854397026e-05],"warmups":[[2048,1.644002080070095e-05]]},{"metadata":{"cpu_freq":"0=5080 MHz","cpu_temp":"coretemp:Package id 0=82 C, coretemp:Core 0=82 C","date":"2026-04-17 14:40:36.278136","duration":0.680936318996828,"load_avg_1min":2.86,"mem_max_rss":24850432,"runnable_threads":1,"uptime":202390.27999019623},"values":[1.6326935252664043e-05,1.629185947251699e-05,1.6355057226746794e-05],"warmups":[[2048,1.647521308427713e-05]]}]},{"metadata":{"description":"Test the performance of pickling.","inner_loops":10,"loops":4096,"name":"pickle_list","pickle_module":"pickle","pickle_protocol":"5","python_cflags":"-fno-strict-overflow -Wsign-compare -DNDEBUG -g -O3 -Wall","python_compiler":"GCC 15.2.0","python_config_args":"'--prefix=/tmp/cpython-build-baseline'","python_executable":"/home/mjbommar/src/cpython/venv/cpython3.15-97bec89492cb-compat-31b33d68c68a/bin/python","python_implementation":"cpython","python_version":"3.15.0a8+ (64-bit) revision 2faceeec5c0","tags":["serialize"],"timer":"clock_gettime(CLOCK_MONOTONIC), resolution: 1.00 ns"},"runs":[{"metadata":{"calibrate_loops":4096,"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:36.955140","duration":0.5525511149899103,"load_avg_1min":2.86,"mem_max_rss":24997888,"runnable_threads":4,"uptime":202390.95706915855},"warmups":[[1,3.3401011023670435e-06],[2,2.7732501621358095e-06],[4,3.003824531333521e-06],[8,2.568749914644286e-06],[16,2.583431341918185e-06],[32,2.6625124519341624e-06],[64,2.629862501635216e-06],[128,2.6948226377498942e-06],[256,2.6178921871178317e-06],[512,2.634366597931148e-06],[1024,2.6286816421361436e-06],[2048,2.6186978999476195e-06],[4096,2.6607179684390305e-06],[4096,2.6512927732369463e-06],[4096,2.6361085453174836e-06],[4096,2.6441870851101614e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:37.456577","duration":0.43724841499351896,"load_avg_1min":2.86,"mem_max_rss":24907776,"runnable_threads":3,"uptime":202391.45845913887},"values":[2.6047218511848768e-06,2.5882583742031785e-06,2.604079882928545e-06],"warmups":[[4096,2.615160253327531e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=70 C, coretemp:Core 0=70 C","date":"2026-04-17 14:40:37.963595","duration":0.44339738998678513,"load_avg_1min":2.87,"mem_max_rss":24907776,"runnable_threads":2,"uptime":202391.9654197693},"values":[2.6374005372531427e-06,2.630345703380499e-06,2.631059179947215e-06],"warmups":[[4096,2.6627294921865994e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=70 C, coretemp:Core 0=70 C","date":"2026-04-17 14:40:38.474086","duration":0.44764642597874627,"load_avg_1min":2.87,"mem_max_rss":24932352,"runnable_threads":2,"uptime":202392.47594475746},"values":[2.6475520748192594e-06,2.6716946294413902e-06,2.6666591068646994e-06],"warmups":[[4096,2.6778799075088956e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:38.996790","duration":0.4612384829961229,"load_avg_1min":2.87,"mem_max_rss":24940544,"runnable_threads":3,"uptime":202392.9986641407},"values":[2.7395453606970933e-06,2.753252270082385e-06,2.752679198891883e-06],"warmups":[[4096,2.753436157121314e-06]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:39.509839","duration":0.4508366770169232,"load_avg_1min":2.87,"mem_max_rss":24907776,"runnable_threads":4,"uptime":202393.5116891861},"values":[2.6778062988341845e-06,2.691617480365949e-06,2.671829150102667e-06],"warmups":[[4096,2.7008707768061413e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:40.018377","duration":0.4460682320059277,"load_avg_1min":2.87,"mem_max_rss":24907776,"runnable_threads":2,"uptime":202394.0201728344},"values":[2.677187597299735e-06,2.6388924560194483e-06,2.649032128942963e-06],"warmups":[[4096,2.668318945353576e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:40.525028","duration":0.4439091000240296,"load_avg_1min":2.87,"mem_max_rss":25092096,"runnable_threads":2,"uptime":202394.5268163681},"values":[2.648560229800978e-06,2.653624658677245e-06,2.643248388523034e-06],"warmups":[[4096,2.6397547365775154e-06]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:40:41.043946","duration":0.4585819240019191,"load_avg_1min":2.87,"mem_max_rss":24907776,"runnable_threads":3,"uptime":202395.0457663536},"values":[2.7554114502947867e-06,2.713527612030475e-06,2.726211377535037e-06],"warmups":[[4096,2.7306660889792054e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:40:41.562561","duration":0.4549996500136331,"load_avg_1min":2.87,"mem_max_rss":24993792,"runnable_threads":1,"uptime":202395.5642864704},"values":[2.699330737243599e-06,2.7035317629042765e-06,2.702071630977798e-06],"warmups":[[4096,2.7499548828302523e-06]]},{"metadata":{"cpu_freq":"0=5067 MHz","cpu_temp":"coretemp:Package id 0=68 C, coretemp:Core 0=68 C","date":"2026-04-17 14:40:42.094757","duration":0.47071607000543736,"load_avg_1min":2.87,"mem_max_rss":24907776,"runnable_threads":2,"uptime":202396.0963294506},"values":[2.7956856200717082e-06,2.7878748291243483e-06,2.812376904159919e-06],"warmups":[[4096,2.8437204591114096e-06]]},{"metadata":{"cpu_freq":"0=5086 MHz","cpu_temp":"coretemp:Package id 0=68 C, coretemp:Core 0=68 C","date":"2026-04-17 14:40:42.599876","duration":0.4442484109895304,"load_avg_1min":2.8,"mem_max_rss":24907776,"runnable_threads":1,"uptime":202396.60166072845},"values":[2.652877051190217e-06,2.6341020017639495e-06,2.6512235834275088e-06],"warmups":[[4096,2.6481163814651152e-06]]},{"metadata":{"cpu_freq":"0=5082 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:40:43.110848","duration":0.449565495015122,"load_avg_1min":2.8,"mem_max_rss":24907776,"runnable_threads":3,"uptime":202397.11244106293},"values":[2.6797796870425827e-06,2.6804469726471327e-06,2.7006776122107112e-06],"warmups":[[4096,2.6680525628819396e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:40:43.608253","duration":0.43644470899016596,"load_avg_1min":2.8,"mem_max_rss":24936448,"runnable_threads":3,"uptime":202397.61005687714},"values":[2.601371411259379e-06,2.5809803467780057e-06,2.598682275589681e-06],"warmups":[[4096,2.6151545164054824e-06]]},{"metadata":{"cpu_freq":"0=5033 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:40:44.111231","duration":0.44214637600816786,"load_avg_1min":2.8,"mem_max_rss":25014272,"runnable_threads":1,"uptime":202398.11292743683},"values":[2.6374290776232103e-06,2.6421330325376856e-06,2.640477539017638e-06],"warmups":[[4096,2.6250915041714507e-06]]},{"metadata":{"cpu_freq":"0=5089 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:40:44.601936","duration":0.43088351999176666,"load_avg_1min":2.8,"mem_max_rss":24907776,"runnable_threads":1,"uptime":202398.6038005352},"values":[2.5695720708540646e-06,2.5621112790474855e-06,2.5639583007830424e-06],"warmups":[[4096,2.56187753890913e-06]]},{"metadata":{"cpu_freq":"0=5062 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:40:45.102584","duration":0.437560289981775,"load_avg_1min":2.8,"mem_max_rss":24977408,"runnable_threads":2,"uptime":202399.10416793823},"values":[2.6010763427564143e-06,2.5861434572505003e-06,2.600899145477342e-06],"warmups":[[4096,2.6421038576529552e-06]]},{"metadata":{"cpu_freq":"0=4983 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:40:45.600607","duration":0.43663604400353506,"load_avg_1min":2.8,"mem_max_rss":24907776,"runnable_threads":3,"uptime":202399.60238599777},"values":[2.587678491039469e-06,2.5860485109774344e-06,2.618487890515553e-06],"warmups":[[4096,2.609290112332019e-06]]},{"metadata":{"cpu_freq":"0=4936 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:46.106377","duration":0.4442125670029782,"load_avg_1min":2.8,"mem_max_rss":24907776,"runnable_threads":2,"uptime":202400.1080043316},"values":[2.637481249934126e-06,2.6357460939152587e-06,2.6845211181125707e-06],"warmups":[[4096,2.637626855062081e-06]]},{"metadata":{"cpu_freq":"0=5082 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:46.623840","duration":0.4573229849920608,"load_avg_1min":2.8,"mem_max_rss":24907776,"runnable_threads":1,"uptime":202400.62552261353},"values":[2.7172455567381347e-06,2.726254125917649e-06,2.719534570161386e-06],"warmups":[[4096,2.741673169026626e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:40:47.122792","duration":0.436144637002144,"load_avg_1min":2.8,"mem_max_rss":24907776,"runnable_threads":3,"uptime":202401.12447214127},"values":[2.598829345856757e-06,2.604022851215859e-06,2.598260473263281e-06],"warmups":[[4096,2.596479320970957e-06]]}]},{"metadata":{"description":"Test the performance of pickling.","inner_loops":20,"loops":32,"name":"pickle_pure_python","pickle_module":"pickle","pickle_protocol":"5","python_cflags":"-fno-strict-overflow -Wsign-compare -DNDEBUG -g -O3 -Wall","python_compiler":"GCC 15.2.0","python_config_args":"'--prefix=/tmp/cpython-build-baseline'","python_executable":"/home/mjbommar/src/cpython/venv/cpython3.15-97bec89492cb-compat-31b33d68c68a/bin/python","python_implementation":"cpython","python_version":"3.15.0a8+ (64-bit) revision 2faceeec5c0","tags":["serialize"],"timer":"clock_gettime(CLOCK_MONOTONIC), resolution: 1.00 ns"},"runs":[{"metadata":{"calibrate_loops":32,"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:40:47.851751","duration":0.6044769650034141,"load_avg_1min":2.73,"mem_max_rss":25985024,"runnable_threads":3,"uptime":202401.8536040783},"warmups":[[1,0.000195872200129088],[2,0.00018835930022760295],[4,0.00018719862528087105],[8,0.00018751105617411667],[16,0.00018547216250226485],[32,0.0001850098375143716],[32,0.0001863095453245478],[32,0.000185727389089152],[32,0.00018868847969315538]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:48.405877","duration":0.4891597969981376,"load_avg_1min":2.73,"mem_max_rss":25964544,"runnable_threads":2,"uptime":202402.4077477455},"values":[0.00018769881094158337,0.00018698932813094872,0.00018724036717685522],"warmups":[[32,0.0001856985953054391]]},{"metadata":{"cpu_freq":"0=5085 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:48.957367","duration":0.4891308379883412,"load_avg_1min":2.73,"mem_max_rss":25993216,"runnable_threads":2,"uptime":202402.95921516418},"values":[0.0001866243562744785,0.000185742314079107,0.00018671097500373436],"warmups":[[32,0.00018851710469789396]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:49.502041","duration":0.4810450559889432,"load_avg_1min":2.73,"mem_max_rss":25989120,"runnable_threads":1,"uptime":202403.50383400917},"values":[0.00018337672186135022,0.00018438673282616946,0.0001833076359162078],"warmups":[[32,0.00018436765781189025]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:50.055794","duration":0.49044721698737703,"load_avg_1min":2.73,"mem_max_rss":25841664,"runnable_threads":3,"uptime":202404.05739593506},"values":[0.00018662384532035502,0.0001884553531454003,0.0001866760687335045],"warmups":[[32,0.00018822214374267788]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:40:50.610870","duration":0.4909918110060971,"load_avg_1min":2.73,"mem_max_rss":25788416,"runnable_threads":2,"uptime":202404.6127331257},"values":[0.0001846938343533111,0.00018675815472306566,0.0001939768875217851],"warmups":[[32,0.0001847825578352058]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:40:51.154865","duration":0.4792254669882823,"load_avg_1min":2.73,"mem_max_rss":25849856,"runnable_threads":1,"uptime":202405.15641593933},"values":[0.00018377128440079106,0.00018311920466658195,0.00018296302500857563],"warmups":[[32,0.00018331978435526253]]},{"metadata":{"cpu_freq":"0=5080 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:51.698797","duration":0.4847234000044409,"load_avg_1min":2.73,"mem_max_rss":26038272,"runnable_threads":2,"uptime":202405.70061135292},"values":[0.0001854872656167572,0.0001844686312324484,0.00018538145313868882],"warmups":[[32,0.00018559971563263388]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:52.233315","duration":0.4739545460033696,"load_avg_1min":2.73,"mem_max_rss":26058752,"runnable_threads":1,"uptime":202406.23508644104},"values":[0.00018016785002146208,0.00018270594846399036,0.00018047947187369573],"warmups":[[32,0.00018085409687955688]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:52.776200","duration":0.4812167560157832,"load_avg_1min":2.6,"mem_max_rss":26095616,"runnable_threads":1,"uptime":202406.77794337273},"values":[0.00018288812811988463,0.00018343401252423063,0.00018547510467215034],"warmups":[[32,0.00018394878434264684]]},{"metadata":{"cpu_freq":"0=5088 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:53.315858","duration":0.47948758202255704,"load_avg_1min":2.6,"mem_max_rss":25915392,"runnable_threads":2,"uptime":202407.3176934719},"values":[0.00018340447654736637,0.000182630782819615,0.00018354124376855906],"warmups":[[32,0.00018330339530621133]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:53.856559","duration":0.48058711999328807,"load_avg_1min":2.6,"mem_max_rss":25985024,"runnable_threads":1,"uptime":202407.8583111763},"values":[0.00018457692031006445,0.00018358565935159277,0.00018175005939156109],"warmups":[[32,0.00018454675623615912]]},{"metadata":{"cpu_freq":"0=5043 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:54.401147","duration":0.4907237240113318,"load_avg_1min":2.6,"mem_max_rss":25821184,"runnable_threads":3,"uptime":202408.40298485756},"values":[0.00018362570472163497,0.00018500702503843058,0.00018538648905632726],"warmups":[[32,0.00018346364377066492]]},{"metadata":{"cpu_freq":"0=5085 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:54.970002","duration":0.4875484539952595,"load_avg_1min":2.6,"mem_max_rss":25948160,"runnable_threads":2,"uptime":202408.97179436684},"values":[0.00018808906875165122,0.00018470090312803223,0.0001852680781212257],"warmups":[[32,0.00018729346716099825]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:55.508278","duration":0.47543904298800044,"load_avg_1min":2.6,"mem_max_rss":25899008,"runnable_threads":2,"uptime":202409.51006746292},"values":[0.00018002744218392763,0.00018234476565339718,0.00018154122340092728],"warmups":[[32,0.00018229392035209457]]},{"metadata":{"cpu_freq":"0=5068 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:40:56.059186","duration":0.487216407986125,"load_avg_1min":2.6,"mem_max_rss":25825280,"runnable_threads":3,"uptime":202410.06075930595},"values":[0.00018385068437964946,0.00018742057345662034,0.00018739033284873586],"warmups":[[32,0.0001867098546881607]]},{"metadata":{"cpu_freq":"0=5002 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:40:56.608607","duration":0.4873105409787968,"load_avg_1min":2.6,"mem_max_rss":26001408,"runnable_threads":2,"uptime":202410.6103951931},"values":[0.0001879294531136111,0.0001861036406353378,0.00018511585153646593],"warmups":[[32,0.00018574065938992135]]},{"metadata":{"cpu_freq":"0=5039 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:57.158555","duration":0.4893302290001884,"load_avg_1min":2.6,"mem_max_rss":26161152,"runnable_threads":2,"uptime":202411.16034579277},"values":[0.0001884661937765486,0.00018750806875686977,0.000185969604717684],"warmups":[[32,0.00018547778595348063]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:57.706409","duration":0.48578277401975356,"load_avg_1min":2.55,"mem_max_rss":25960448,"runnable_threads":1,"uptime":202411.70822691917},"values":[0.0001851806234299147,0.00018613480624480873,0.00018496866559871705],"warmups":[[32,0.00018615066719576134]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:58.258056","duration":0.48843028699047863,"load_avg_1min":2.55,"mem_max_rss":26083328,"runnable_threads":1,"uptime":202412.25984334946},"values":[0.00018764574065244233,0.00018586918909022643,0.00018450600314281473],"warmups":[[32,0.00018831707343451852]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:40:58.806255","duration":0.48468444400350563,"load_avg_1min":2.55,"mem_max_rss":25833472,"runnable_threads":1,"uptime":202412.80809998512},"values":[0.00018543669061727998,0.00018488197497390502,0.0001839103827933286],"warmups":[[32,0.00018677579064387828]]}]},{"metadata":{"command":"/home/mjbommar/src/cpython/venv/cpython3.15-97bec89492cb-compat-31b33d68c68a/bin/python -c pass","description":"Performance of the Python startup","loops":16,"name":"python_startup","tags":["startup"]},"runs":[{"metadata":{"calibrate_loops":16,"command_max_rss":16605184,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:41:00.819701","duration":1.8629828230186831,"load_avg_1min":2.55,"runnable_threads":1,"uptime":202414.8212940693},"warmups":[[1,0.008429292996879667],[2,0.00818729100865312],[4,0.008974972748546861],[8,0.008091179002803983],[16,0.008033421499931137],[16,0.007919465311715612],[16,0.007860261812311364],[16,0.007888143250966095],[16,0.007910501124570146],[16,0.008003018310773768],[16,0.007691933749811142],[16,0.007946101875859313],[16,0.008163763437551097],[16,0.008005090186998132],[16,0.007990601376150153]]},{"metadata":{"command_max_rss":16580608,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=59 C, coretemp:Core 0=59 C","date":"2026-04-17 14:41:02.538122","duration":1.6568840130057652,"load_avg_1min":2.58,"runnable_threads":2,"uptime":202416.53970718384},"values":[0.007826945811757469,0.008080204876023345,0.008210435626097023,0.00814315862589865,0.007913167437436641,0.007915062000392936,0.008022857813557494,0.007883338750616531,0.00787223581392027,0.007731041874649236],"warmups":[[16,0.008170922499630251]]},{"metadata":{"command_max_rss":16613376,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=62 C, coretemp:Core 0=62 C","date":"2026-04-17 14:41:04.208647","duration":1.611094886000501,"load_avg_1min":2.58,"runnable_threads":1,"uptime":202418.21022176743},"values":[0.007659746375793475,0.007676864312088583,0.007738306125247618,0.007752564062684542,0.007835279624487157,0.007833329875211348,0.007760665625028196,0.0077671191247645766,0.007764550686260918,0.007754503187243245],"warmups":[[16,0.007794490311425761]]},{"metadata":{"command_max_rss":16629760,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:41:05.900949","duration":1.6313851280137897,"load_avg_1min":2.58,"runnable_threads":2,"uptime":202419.90253925323},"values":[0.007959626624142402,0.00786824931310548,0.007690595000894973,0.007616867813339923,0.008071805186773418,0.007886040812081774,0.007743288313577068,0.007795408624588163,0.007994440875336295,0.007868225124184391],"warmups":[[16,0.00800288393838855]]},{"metadata":{"command_max_rss":16625664,"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=55 C, coretemp:Core 0=55 C","date":"2026-04-17 14:41:07.630949","duration":1.6696115840168204,"load_avg_1min":2.46,"runnable_threads":2,"uptime":202421.63254070282},"values":[0.007604692937093205,0.0076675116888509365,0.0077490827497967985,0.00800121899919759,0.007938412187286303,0.008363640437892172,0.009602673186236643,0.008056907248828793,0.007854124251025496,0.007930643500003498],"warmups":[[16,0.007987225748365745]]},{"metadata":{"command_max_rss":16584704,"cpu_freq":"0=5085 MHz","cpu_temp":"coretemp:Package id 0=62 C, coretemp:Core 0=62 C","date":"2026-04-17 14:41:09.298825","duration":1.6070921139908023,"load_avg_1min":2.46,"runnable_threads":1,"uptime":202423.3003871441},"values":[0.007605282187796547,0.007903621437435504,0.007794863311573863,0.0077474266254284885,0.00763449699843477,0.0077779332495993,0.007704198187639122,0.0075806459371960955,0.007987912375028827,0.0077685551877948456],"warmups":[[16,0.007823266187187983]]},{"metadata":{"command_max_rss":16670720,"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:41:10.958284","duration":1.6001614279812202,"load_avg_1min":2.46,"runnable_threads":1,"uptime":202424.95986819267},"values":[0.007889094813435804,0.0078468072515534,0.00766759231191827,0.007901648812548956,0.0075859849366679555,0.00763397318587522,0.0075586631246551406,0.007720949563008617,0.007787797936543939,0.007635160751306103],"warmups":[[16,0.007644568750038161]]},{"metadata":{"command_max_rss":16588800,"cpu_freq":"0=4949 MHz","cpu_temp":"coretemp:Package id 0=59 C, coretemp:Core 0=59 C","date":"2026-04-17 14:41:12.643213","duration":1.6254638229729608,"load_avg_1min":2.42,"runnable_threads":3,"uptime":202426.64501428604},"values":[0.00762423268679413,0.007584942062749178,0.007892221248766873,0.00774698737586732,0.007677461311686784,0.007902115687102196,0.00801307737492607,0.007916417062006076,0.007904132311523426,0.007953193124194513],"warmups":[[16,0.007929888875878532]]},{"metadata":{"command_max_rss":16547840,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:41:14.338092","duration":1.6345841549918987,"load_avg_1min":2.42,"runnable_threads":1,"uptime":202428.3396241665},"values":[0.007764498624965199,0.008278731062091538,0.007676061999518424,0.00765646906074835,0.007893766187407891,0.007885087063186802,0.007852758437365992,0.007995269250386627,0.007848043685953598,0.007827693500075839],"warmups":[[16,0.008002575686987257]]},{"metadata":{"command_max_rss":16646144,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:41:16.033863","duration":1.6358940440113656,"load_avg_1min":2.42,"runnable_threads":2,"uptime":202430.0354528427},"values":[0.008002511251106625,0.007910525187980966,0.0077429015618690755,0.008192833563953172,0.007938753749840544,0.007777421937134932,0.007673824562516529,0.008100873938019504,0.007934170000226004,0.007762734374409774],"warmups":[[16,0.007773400937367114]]},{"metadata":{"command_max_rss":16650240,"cpu_freq":"0=4999 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:41:17.730650","duration":1.6349460739875212,"load_avg_1min":2.31,"runnable_threads":3,"uptime":202431.73228549957},"values":[0.007921521999378456,0.0076335511257639155,0.00788975693831162,0.007699782312556636,0.007675845999983721,0.007975448375873384,0.0076899718114873394,0.00775507437538181,0.008915552438338636,0.008006484875295428],"warmups":[[16,0.007788680562953232]]},{"metadata":{"command_max_rss":16576512,"cpu_freq":"0=5090 MHz","cpu_temp":"coretemp:Package id 0=74 C, coretemp:Core 0=62 C","date":"2026-04-17 14:41:19.457017","duration":1.665750890999334,"load_avg_1min":2.31,"runnable_threads":3,"uptime":202433.45855879784},"values":[0.008310091063322034,0.008806632687992533,0.008377944062885945,0.007784969375279616,0.008222249936807202,0.007668388687307015,0.007868352624427644,0.007882924126533908,0.007625148000443005,0.00791333587585541],"warmups":[[16,0.008169835062290076]]},{"metadata":{"command_max_rss":16588800,"cpu_freq":"0=5066 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:41:21.133532","duration":1.6160427189897746,"load_avg_1min":2.31,"runnable_threads":1,"uptime":202435.1351416111},"values":[0.007997703374712728,0.007753999123451649,0.0080051421882672,0.007739628812487354,0.007610159249452408,0.007605855687870644,0.008020636874789489,0.007689426623983309,0.007565053687358159,0.00799861143786984],"warmups":[[16,0.007889309874371975]]},{"metadata":{"command_max_rss":16580608,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:41:22.816365","duration":1.6238894810085185,"load_avg_1min":2.2,"runnable_threads":2,"uptime":202436.81801056862},"values":[0.007783274937537499,0.007961801249621203,0.008061526499659522,0.007890236813182128,0.008281860998977209,0.007622529061336536,0.007622335124324309,0.0075827961863979,0.007785583062286605,0.00787900831164734],"warmups":[[16,0.007761476312225568]]},{"metadata":{"command_max_rss":16584704,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=62 C, coretemp:Core 0=62 C","date":"2026-04-17 14:41:24.502783","duration":1.6263189479941502,"load_avg_1min":2.2,"runnable_threads":1,"uptime":202438.50429439545},"values":[0.00797015281386848,0.007991129999936675,0.007811374687662465,0.008019462124138954,0.007765222124362481,0.007858490438593435,0.007838915125830681,0.007882892876295955,0.0077421961887012,0.0076383687501220265],"warmups":[[16,0.007762468248984078]]},{"metadata":{"command_max_rss":16646144,"cpu_freq":"0=5046 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:41:26.169423","duration":1.6081235829915386,"load_avg_1min":2.2,"runnable_threads":2,"uptime":202440.17103290558},"values":[0.008049445437791292,0.00767831574921729,0.007859268187530688,0.007575560750410659,0.0075431217501318315,0.007599241749630892,0.007814266873538145,0.0078053613142401446,0.007639767500222661,0.007953597936648293],"warmups":[[16,0.007799466498909169]]},{"metadata":{"command_max_rss":16609280,"cpu_freq":"0=4966 MHz","cpu_temp":"coretemp:Package id 0=62 C, coretemp:Core 0=62 C","date":"2026-04-17 14:41:27.824340","duration":1.5966773469990585,"load_avg_1min":2.1,"runnable_threads":1,"uptime":202441.82592225075},"values":[0.007622872124557034,0.0076695693114743335,0.00789724556125293,0.007669819375223597,0.007921206750324927,0.007561562750197481,0.007549343376012985,0.007571266187369474,0.007781098436680622,0.007816932498826645],"warmups":[[16,0.007622074563187198]]},{"metadata":{"command_max_rss":16556032,"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:41:29.494684","duration":1.6100276409997605,"load_avg_1min":2.1,"runnable_threads":1,"uptime":202443.49629616737},"values":[0.007997458124009427,0.007614537875269889,0.007610190188643173,0.007609933123603696,0.0077738411873724544,0.007778801062158891,0.007677968875213992,0.007704367373662535,0.007748466061457293,0.007811676561686909],"warmups":[[16,0.007898345374997007]]},{"metadata":{"command_max_rss":16625664,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:41:31.217336","duration":1.6631269850186072,"load_avg_1min":2.1,"runnable_threads":1,"uptime":202445.21901726723},"values":[0.008060083811869845,0.008008744936887524,0.00836269700084813,0.008234439375883085,0.008118844125419855,0.008238556500145933,0.007811488751030993,0.007683447000090382,0.007827329625797574,0.007965521062942571],"warmups":[[16,0.008109908061669557]]},{"metadata":{"command_max_rss":16601088,"cpu_freq":"0=4989 MHz","cpu_temp":"coretemp:Package id 0=72 C, coretemp:Core 0=59 C","date":"2026-04-17 14:41:32.947853","duration":1.6702966549783014,"load_avg_1min":2.1,"runnable_threads":3,"uptime":202446.94959831238},"values":[0.008048346562645747,0.00820838412437297,0.008361001937373658,0.007746639686956769,0.008152123000400024,0.007913074312455137,0.008034272188524483,0.008208634812035598,0.008353234625246841,0.00783697456245136],"warmups":[[16,0.008030608938497608]]},{"metadata":{"command_max_rss":16531456,"cpu_freq":"0=5077 MHz","cpu_temp":"coretemp:Package id 0=59 C, coretemp:Core 0=59 C","date":"2026-04-17 14:41:34.678905","duration":1.6693760869966354,"load_avg_1min":2.1,"runnable_threads":2,"uptime":202448.68061351776},"values":[0.008128377186949365,0.007971375438501127,0.008205550750062685,0.008093412750895368,0.00793770656309789,0.008176837751307175,0.007891937188105658,0.007851870188460452,0.008041469311137917,0.008348781000677263],"warmups":[[16,0.00819586393845384]]}]},{"metadata":{"command":"/home/mjbommar/src/cpython/venv/cpython3.15-97bec89492cb-compat-31b33d68c68a/bin/python -S -c pass","description":"Performance of the Python startup","loops":32,"name":"python_startup_no_site","tags":["startup"]},"runs":[{"metadata":{"calibrate_loops":32,"command_max_rss":16592896,"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:41:36.858742","duration":2.0509513139841147,"load_avg_1min":2.1,"runnable_threads":2,"uptime":202450.86030244827},"warmups":[[1,0.005349957995349541],[2,0.004695605501183309],[4,0.0044286647462286055],[8,0.004562645375699503],[16,0.004525736312643858],[32,0.004421268781698018],[32,0.004341517124885286],[32,0.004393388906464679],[32,0.00432082681254542],[32,0.0043340341244402225],[32,0.004632834218682547],[32,0.00455852962568315],[32,0.004308682938244601],[32,0.004328657624682819],[32,0.004327642343923799],[32,0.004367142500086629]]},{"metadata":{"command_max_rss":16654336,"cpu_freq":"0=5065 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:41:38.721832","duration":1.801360220008064,"load_avg_1min":2.09,"runnable_threads":2,"uptime":202452.72344326973},"values":[0.004458871093447669,0.0045403049689412,0.004397196999889275,0.004397743406116206,0.004272727313036739,0.004563081218293519,0.004426692749802896,0.004435163155903865,0.004250545749528101,0.004308206906898704],"warmups":[[32,0.004436412749782903]]},{"metadata":{"command_max_rss":16547840,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:41:40.578008","duration":1.7952738459862303,"load_avg_1min":2.09,"runnable_threads":2,"uptime":202454.57954716682},"values":[0.004491968437832838,0.004484436468374042,0.004330883374677796,0.0042856608124566264,0.004341025343819638,0.004306714906306297,0.004395589000523614,0.004309726531573688,0.004245500874276331,0.004729352531285258],"warmups":[[32,0.0043765535001512035]]},{"metadata":{"command_max_rss":16613376,"cpu_freq":"0=4981 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:41:42.423685","duration":1.7856551430013496,"load_avg_1min":2.09,"runnable_threads":1,"uptime":202456.42539596558},"values":[0.004315951124226558,0.00445588959428278,0.004378640187496785,0.004338111156357627,0.004424322999511787,0.0042791023433892406,0.004364761124634242,0.004429286155755108,0.004347260937720421,0.004407429343700642],"warmups":[[32,0.0042547550629024045]]},{"metadata":{"command_max_rss":16596992,"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:41:44.259678","duration":1.7755960400099866,"load_avg_1min":2.08,"runnable_threads":1,"uptime":202458.26123309135},"values":[0.004401424156640132,0.004280095218746283,0.004387213093650644,0.004335198749686242,0.004280768124772294,0.004283964655769523,0.004366965781628096,0.004343855000115582,0.004394521250105754,0.004264842344127828],"warmups":[[32,0.004413149500578584]]},{"metadata":{"command_max_rss":16601088,"cpu_freq":"0=5082 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:41:46.109836","duration":1.7899157450010534,"load_avg_1min":2.08,"runnable_threads":2,"uptime":202460.1113936901},"values":[0.004313318593631266,0.004433692031852843,0.0043951144998573,0.004451613750461547,0.004424357156494807,0.004303097844058357,0.0044181178436701884,0.004384197843137372,0.0043086361556561315,0.0043783733126474544],"warmups":[[32,0.004333574187512568]]},{"metadata":{"command_max_rss":16625664,"cpu_freq":"0=5055 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:41:47.950010","duration":1.780023347993847,"load_avg_1min":1.99,"runnable_threads":2,"uptime":202461.95162034035},"values":[0.00440807228187623,0.004318069843975536,0.004320187687881116,0.004433644125128922,0.0044628539371842635,0.004316441812989069,0.0042905040936602745,0.004304509874600626,0.00425772559356119,0.00433606621936633],"warmups":[[32,0.004402836530971399]]},{"metadata":{"command_max_rss":16568320,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=76 C, coretemp:Core 0=66 C","date":"2026-04-17 14:41:49.791312","duration":1.780962991004344,"load_avg_1min":1.99,"runnable_threads":1,"uptime":202463.79284977913},"values":[0.00432982712482044,0.004341703686804976,0.004409671718349273,0.004370180187834194,0.004366922499684733,0.004572910562274046,0.0042665784058044665,0.004246821218657715,0.004273338312486885,0.004252582718436315],"warmups":[[32,0.004441952905835933]]},{"metadata":{"command_max_rss":16576512,"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=68 C, coretemp:Core 0=68 C","date":"2026-04-17 14:41:51.601715","duration":1.7505082950228825,"load_avg_1min":1.99,"runnable_threads":2,"uptime":202465.60340857506},"values":[0.004386196468658454,0.00422707581310533,0.00426246999995783,0.004217602031530987,0.004220263187562523,0.0042519910630289814,0.004355358656539465,0.004245438438374549,0.004301517124986276,0.004233556624967605],"warmups":[[32,0.0043242574683972634]]},{"metadata":{"command_max_rss":16592896,"cpu_freq":"0=5083 MHz","cpu_temp":"coretemp:Package id 0=59 C, coretemp:Core 0=59 C","date":"2026-04-17 14:41:53.411528","duration":1.7496283529908396,"load_avg_1min":1.99,"runnable_threads":1,"uptime":202467.41309809685},"values":[0.0043157426562174805,0.004405011905873835,0.004233071124872367,0.004238534249452641,0.004253627718753705,0.004256179687217809,0.004252726093909587,0.004339236062151031,0.004212509000353748,0.004254394843883347],"warmups":[[32,0.004241207406266767]]},{"metadata":{"command_max_rss":16605184,"cpu_freq":"0=5020 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:41:55.220775","duration":1.7499940480047371,"load_avg_1min":1.99,"runnable_threads":2,"uptime":202469.22234725952},"values":[0.004222259687594487,0.004274557843928051,0.004359629249847785,0.004209307375276694,0.004264683874680486,0.00421037125033763,0.004275237250112696,0.004235075968608726,0.0043049121250078315,0.004311962874453457],"warmups":[[32,0.004269243750059104]]},{"metadata":{"command_max_rss":16617472,"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=58 C, coretemp:Core 0=58 C","date":"2026-04-17 14:41:57.045582","duration":1.7637520210118964,"load_avg_1min":1.99,"runnable_threads":3,"uptime":202471.04721474648},"values":[0.004221205906105752,0.004222879062581342,0.004218975249386858,0.004319506281717622,0.004260212625013082,0.004278913625057612,0.0042919177813018905,0.004377079219011648,0.004449401531019248,0.004461844750039745],"warmups":[[32,0.004240892999405332]]},{"metadata":{"command_max_rss":16560128,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=59 C, coretemp:Core 0=59 C","date":"2026-04-17 14:41:58.863393","duration":1.7544002129870933,"load_avg_1min":1.91,"runnable_threads":3,"uptime":202472.8650212288},"values":[0.004237260936861276,0.004187212625765824,0.004252922187333752,0.004268358593435551,0.004347526813035074,0.004261016062628187,0.004254606687936757,0.004283619094167079,0.004298518312680244,0.004284287375412532],"warmups":[[32,0.004420597312673635]]},{"metadata":{"command_max_rss":16613376,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:42:00.681661","duration":1.7580540080089122,"load_avg_1min":1.91,"runnable_threads":2,"uptime":202474.68327403069},"values":[0.004317233905567264,0.004278887719010527,0.0042071577181559405,0.004304906688048504,0.004273317968909396,0.004272719531400071,0.0043703265000658575,0.004274132406862918,0.004211252218738082,0.00426557090577262],"warmups":[[32,0.004425398874445818]]},{"metadata":{"command_max_rss":16564224,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:42:02.489112","duration":1.7472645529778674,"load_avg_1min":1.91,"runnable_threads":1,"uptime":202476.4906938076},"values":[0.004277689937225659,0.0042478829382162075,0.00425590250051755,0.004219381594339211,0.004257655687069928,0.004203636312013259,0.004235445125232218,0.004505002719270124,0.004220203499244235,0.004187191593700845],"warmups":[[32,0.004287762531930639]]},{"metadata":{"command_max_rss":16637952,"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:42:04.397283","duration":1.8483610239927657,"load_avg_1min":1.84,"runnable_threads":2,"uptime":202478.39898371696},"values":[0.004448258719094156,0.004493136250857788,0.004516183625128178,0.004473568718822207,0.004553241499706928,0.004536551999990479,0.004610428062733263,0.004529346812887525,0.004549664000478515,0.0044945454683329444],"warmups":[[32,0.0044308519372862065]]},{"metadata":{"command_max_rss":16560128,"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:06.296031","duration":1.8356042280211113,"load_avg_1min":1.84,"runnable_threads":1,"uptime":202480.29767012596},"values":[0.004496976875088876,0.004438527093952871,0.0046752132184337825,0.004453151780580811,0.004473755969229387,0.004467432530873339,0.004442276844201842,0.0044572674996743444,0.00453477871906216,0.00442187831231422],"warmups":[[32,0.004547290218397393]]},{"metadata":{"command_max_rss":16580608,"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:08.200744","duration":1.8428215700259898,"load_avg_1min":3.38,"runnable_threads":1,"uptime":202482.2023088932},"values":[0.004403586250191438,0.004421215687216318,0.004435660655872198,0.005240833906100306,0.0044474146561697125,0.004496342906350037,0.004471094468499359,0.004396920906401647,0.004398280249915842,0.00445960350043606],"warmups":[[32,0.0044823805619671475]]},{"metadata":{"command_max_rss":16564224,"cpu_freq":"0=5085 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:10.026083","duration":1.763107131992001,"load_avg_1min":3.38,"runnable_threads":1,"uptime":202484.02765536308},"values":[0.004439428124896949,0.004431826062500477,0.004382553844152426,0.00429239106233581,0.004190185311927053,0.004126819593693654,0.004126818999793613,0.004271474374945683,0.004262459968231269,0.004209596750115452],"warmups":[[32,0.004609752343640139]]},{"metadata":{"command_max_rss":16576512,"cpu_freq":"0=4983 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:42:11.816692","duration":1.7295061470067594,"load_avg_1min":3.38,"runnable_threads":1,"uptime":202485.81820631027},"values":[0.004272713531463523,0.004257215156030725,0.004217724156660552,0.004238417875058076,0.004167520844021055,0.0042649143124435795,0.004172810062300414,0.004157528718678805,0.004183712218036817,0.004233638062032696],"warmups":[[32,0.004277981656741758]]},{"metadata":{"command_max_rss":16556032,"cpu_freq":"0=4981 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:13.607608","duration":1.7308158829982858,"load_avg_1min":3.19,"runnable_threads":2,"uptime":202487.60920596123},"values":[0.0042879031871052575,0.0042626003742043395,0.004279967592992762,0.00419264762513194,0.00417819121867069,0.0042568644994389615,0.004331868219196622,0.0041654738124634605,0.004164672781371337,0.004190684593595506],"warmups":[[32,0.004177023624833964]]}]},{"metadata":{"description":"Microbenchmark for Python's sequence unpacking.","inner_loops":400,"loops":16384,"name":"unpack_sequence","python_cflags":"-fno-strict-overflow -Wsign-compare -DNDEBUG -g -O3 -Wall","python_compiler":"GCC 15.2.0","python_config_args":"'--prefix=/tmp/cpython-build-baseline'","python_executable":"/home/mjbommar/src/cpython/venv/cpython3.15-97bec89492cb-compat-31b33d68c68a/bin/python","python_implementation":"cpython","python_version":"3.15.0a8+ (64-bit) revision 2faceeec5c0","tags":[],"timer":"clock_gettime(CLOCK_MONOTONIC), resolution: 1.00 ns"},"runs":[{"metadata":{"calibrate_loops":16384,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:14.427724","duration":0.6840741020278074,"load_avg_1min":3.19,"mem_max_rss":25751552,"runnable_threads":1,"uptime":202488.4295282364},"warmups":[[1,5.1555034588091076e-08],[2,4.900499334326014e-08],[4,4.9014379328582433e-08],[8,4.8555621106061154e-08],[16,4.995140898245154e-08],[32,6.843867140560179e-08],[64,2.9892188422309115e-08],[128,4.217712898935133e-08],[256,3.1209091559958325e-08],[512,2.5401098611155247e-08],[1024,2.2900974130379837e-08],[2048,2.1238728038497358e-08],[4096,2.0495277102128283e-08],[8192,2.0428793323645777e-08],[16384,2.0413620913650733e-08],[16384,2.0299944609725174e-08],[16384,2.021276977792752e-08],[16384,2.0429055327397803e-08]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:42:15.028161","duration":0.5388728640100453,"load_avg_1min":3.19,"mem_max_rss":25825280,"runnable_threads":1,"uptime":202489.03002595901},"values":[2.030873337055539e-08,1.9921941221134887e-08,2.0113956606948592e-08],"warmups":[[16384,2.022925476019566e-08]]},{"metadata":{"cpu_freq":"0=5083 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:42:15.630745","duration":0.539033234003,"load_avg_1min":3.19,"mem_max_rss":25751552,"runnable_threads":1,"uptime":202489.63252568245},"values":[2.020385803103153e-08,2.0191718292927875e-08,2.0242539369164093e-08],"warmups":[[16384,1.9972178648686166e-08]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:42:16.253299","duration":0.5601220919925254,"load_avg_1min":3.19,"mem_max_rss":25751552,"runnable_threads":1,"uptime":202490.25518345833},"values":[2.1561529393032684e-08,2.064752151920146e-08,2.0509443663385697e-08],"warmups":[[16384,2.112463867387504e-08]]},{"metadata":{"cpu_freq":"0=5087 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:42:16.856383","duration":0.5422759830253199,"load_avg_1min":3.19,"mem_max_rss":25751552,"runnable_threads":1,"uptime":202490.85820269585},"values":[1.9917130584801156e-08,2.044083283081477e-08,2.069903900281389e-08],"warmups":[[16384,2.008679092391219e-08]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:42:17.462653","duration":0.5431472740019672,"load_avg_1min":3.19,"mem_max_rss":25911296,"runnable_threads":1,"uptime":202491.46445703506},"values":[2.0442101895667975e-08,2.037231506157866e-08,2.031121200563035e-08],"warmups":[[16384,2.0149548181080947e-08]]},{"metadata":{"cpu_freq":"0=5081 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:42:18.064156","duration":0.5405000550090335,"load_avg_1min":3.09,"mem_max_rss":25763840,"runnable_threads":4,"uptime":202492.06582665443},"values":[2.0121420742924555e-08,2.0193031469162293e-08,2.0420578761282117e-08],"warmups":[[16384,2.0156779476643295e-08]]},{"metadata":{"cpu_freq":"0=4999 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:18.663046","duration":0.5369967670121696,"load_avg_1min":3.09,"mem_max_rss":25751552,"runnable_threads":2,"uptime":202492.66491913795},"values":[1.9963285065038862e-08,2.010627319748437e-08,2.0271519312053952e-08],"warmups":[[16384,1.9959211727815784e-08]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:19.270657","duration":0.5473067209823057,"load_avg_1min":3.09,"mem_max_rss":25845760,"runnable_threads":2,"uptime":202493.2725121975},"values":[2.0359980017481405e-08,2.0253354491295282e-08,2.0718942415065556e-08],"warmups":[[16384,2.050568420397525e-08]]},{"metadata":{"cpu_freq":"0=4983 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:19.873393","duration":0.5410904099990148,"load_avg_1min":3.09,"mem_max_rss":25772032,"runnable_threads":6,"uptime":202493.8753297329},"values":[2.042796584778017e-08,2.0145254517878185e-08,2.0273192289366192e-08],"warmups":[[16384,2.0067497255027433e-08]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:20.474822","duration":0.5399231310002506,"load_avg_1min":3.09,"mem_max_rss":25808896,"runnable_threads":1,"uptime":202494.4765777588},"values":[2.0472857364950414e-08,2.0127864530650186e-08,1.9940909883331413e-08],"warmups":[[16384,2.0208410647093444e-08]]},{"metadata":{"cpu_freq":"0=5084 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:21.078337","duration":0.5422515160171315,"load_avg_1min":3.09,"mem_max_rss":25751552,"runnable_threads":3,"uptime":202495.07991623878},"values":[2.0442122043995425e-08,2.0393540340890583e-08,2.0546028438594987e-08],"warmups":[[16384,1.9803414459396152e-08]]},{"metadata":{"cpu_freq":"0=4942 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:21.687898","duration":0.5474564500036649,"load_avg_1min":3.09,"mem_max_rss":25751552,"runnable_threads":3,"uptime":202495.6898150444},"values":[2.0386603694078075e-08,2.0336183927938123e-08,2.061116455287504e-08],"warmups":[[16384,2.0537012481725016e-08]]},{"metadata":{"cpu_freq":"0=4897 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:42:22.294944","duration":0.5454322059813421,"load_avg_1min":3.09,"mem_max_rss":25751552,"runnable_threads":1,"uptime":202496.29689526558},"values":[2.0467236176990866e-08,2.0382180325739796e-08,2.0528472295389123e-08],"warmups":[[16384,2.021922897110784e-08]]},{"metadata":{"cpu_freq":"0=5056 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:42:22.899671","duration":0.5416693989827763,"load_avg_1min":2.92,"mem_max_rss":25751552,"runnable_threads":1,"uptime":202496.90146875381},"values":[2.0526974489065707e-08,2.0133328701987807e-08,2.0174608157397245e-08],"warmups":[[16384,2.0152764279579572e-08]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=69 C, coretemp:Core 0=63 C","date":"2026-04-17 14:42:23.506089","duration":0.5442313250096049,"load_avg_1min":2.92,"mem_max_rss":25985024,"runnable_threads":2,"uptime":202497.50795340538},"values":[2.0386070254119205e-08,2.0493020933542993e-08,2.0341841735493915e-08],"warmups":[[16384,2.0221061247660545e-08]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=69 C, coretemp:Core 0=63 C","date":"2026-04-17 14:42:24.106303","duration":0.5386473320249934,"load_avg_1min":2.92,"mem_max_rss":25751552,"runnable_threads":1,"uptime":202498.107970953},"values":[2.0195223542351925e-08,1.9912011413047994e-08,2.0116129149094773e-08],"warmups":[[16384,2.039558456345958e-08]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:42:24.716034","duration":0.5479090700100642,"load_avg_1min":2.92,"mem_max_rss":25751552,"runnable_threads":1,"uptime":202498.7178053856},"values":[2.0484481204618988e-08,2.0448925015514873e-08,2.052970596189141e-08],"warmups":[[16384,2.0476673276981217e-08]]},{"metadata":{"cpu_freq":"0=5028 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:42:25.321964","duration":0.5426104420039337,"load_avg_1min":2.92,"mem_max_rss":25751552,"runnable_threads":5,"uptime":202499.32379341125},"values":[2.020974059657732e-08,2.0525330048926095e-08,2.03713908364378e-08],"warmups":[[16384,2.009115341206069e-08]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:42:25.943752","duration":0.560108023986686,"load_avg_1min":2.92,"mem_max_rss":25751552,"runnable_threads":1,"uptime":202499.94558358192},"values":[2.245673751843924e-08,2.0119474792856808e-08,2.058537780680325e-08],"warmups":[[16384,2.0646233824805903e-08]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:42:26.556259","duration":0.5504108729946893,"load_avg_1min":2.92,"mem_max_rss":25751552,"runnable_threads":1,"uptime":202500.55803465843},"values":[2.076160659392201e-08,2.0671915743619708e-08,2.0016338959649717e-08],"warmups":[[16384,2.0941632383753017e-08]]}]},{"metadata":{"description":"Test the performance of pickling.","inner_loops":20,"loops":1024,"name":"unpickle","pickle_module":"pickle","pickle_protocol":"5","python_cflags":"-fno-strict-overflow -Wsign-compare -DNDEBUG -g -O3 -Wall","python_compiler":"GCC 15.2.0","python_config_args":"'--prefix=/tmp/cpython-build-baseline'","python_executable":"/home/mjbommar/src/cpython/venv/cpython3.15-97bec89492cb-compat-31b33d68c68a/bin/python","python_implementation":"cpython","python_version":"3.15.0a8+ (64-bit) revision 2faceeec5c0","tags":["serialize"],"timer":"clock_gettime(CLOCK_MONOTONIC), resolution: 1.00 ns"},"runs":[{"metadata":{"calibrate_loops":1024,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=68 C, coretemp:Core 0=68 C","date":"2026-04-17 14:42:27.582282","duration":0.8991839409864042,"load_avg_1min":2.77,"mem_max_rss":24854528,"runnable_threads":2,"uptime":202501.58409237862},"warmups":[[1,9.786999726202339e-06],[2,8.512200292898341e-06],[4,8.609200085629709e-06],[8,8.566056203562767e-06],[16,8.784199962974526e-06],[32,8.626784347143256e-06],[64,8.553428915547557e-06],[128,8.719238280718855e-06],[256,8.768134568981622e-06],[512,8.769753222281906e-06],[1024,8.70110561521642e-06],[1024,8.582657616784673e-06],[1024,8.60957797925721e-06],[1024,8.726082373300415e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=68 C, coretemp:Core 0=68 C","date":"2026-04-17 14:42:28.372696","duration":0.7232848589774221,"load_avg_1min":2.77,"mem_max_rss":25092096,"runnable_threads":2,"uptime":202502.37446951866},"values":[8.765864649262767e-06,8.659268213762062e-06,8.675076954034466e-06],"warmups":[[1024,8.69395380931337e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=68 C, coretemp:Core 0=68 C","date":"2026-04-17 14:42:29.161450","duration":0.7281574180233292,"load_avg_1min":2.77,"mem_max_rss":24862720,"runnable_threads":2,"uptime":202503.16328978539},"values":[8.799113672353087e-06,8.744377147706928e-06,8.71567548870189e-06],"warmups":[[1024,8.77301015549392e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=68 C, coretemp:Core 0=68 C","date":"2026-04-17 14:42:29.961394","duration":0.7373282840126194,"load_avg_1min":2.77,"mem_max_rss":24842240,"runnable_threads":1,"uptime":202503.9633448124},"values":[8.877805274210005e-06,8.76703198287032e-06,8.721658007004862e-06],"warmups":[[1024,9.095667479641634e-06]]},{"metadata":{"cpu_freq":"0=4902 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:42:30.754313","duration":0.7323791979870293,"load_avg_1min":2.77,"mem_max_rss":25047040,"runnable_threads":2,"uptime":202504.75622487068},"values":[8.754227978613472e-06,8.774412060574832e-06,8.907410058611732e-06],"warmups":[[1024,8.766094823897675e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:42:31.552428","duration":0.7349861119873822,"load_avg_1min":2.77,"mem_max_rss":25006080,"runnable_threads":2,"uptime":202505.5543065071},"values":[8.889892235686148e-06,8.872354395350613e-06,8.763073877560145e-06],"warmups":[[1024,8.824880713120819e-06]]},{"metadata":{"cpu_freq":"0=4948 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:32.347747","duration":0.7309203120239545,"load_avg_1min":2.77,"mem_max_rss":24875008,"runnable_threads":3,"uptime":202506.34967899323},"values":[8.694009864029795e-06,8.720637011094822e-06,8.765587060111102e-06],"warmups":[[1024,8.963838963893522e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:33.142605","duration":0.7314354330010246,"load_avg_1min":2.87,"mem_max_rss":25042944,"runnable_threads":3,"uptime":202507.14470982552},"values":[8.824473340496297e-06,8.751330419443093e-06,8.72618989262719e-06],"warmups":[[1024,8.867480273977435e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=78 C, coretemp:Core 0=78 C","date":"2026-04-17 14:42:33.913684","duration":0.7084504090016708,"load_avg_1min":2.87,"mem_max_rss":24846336,"runnable_threads":2,"uptime":202507.9154701233},"values":[8.461040918916751e-06,8.56251777321404e-06,8.540572802928637e-06],"warmups":[[1024,8.479745605427525e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:42:34.709429","duration":0.7309247789962683,"load_avg_1min":2.87,"mem_max_rss":24883200,"runnable_threads":4,"uptime":202508.71127605438},"values":[8.936688085725564e-06,8.684229786126708e-06,8.749298584120879e-06],"warmups":[[1024,8.790875828879052e-06]]},{"metadata":{"cpu_freq":"0=5083 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:42:35.500441","duration":0.7304470780072734,"load_avg_1min":2.87,"mem_max_rss":24838144,"runnable_threads":2,"uptime":202509.50224494934},"values":[8.784279931717264e-06,8.837600684330483e-06,8.781834276305745e-06],"warmups":[[1024,8.73434887722624e-06]]},{"metadata":{"cpu_freq":"0=5045 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:36.288686","duration":0.7261786999879405,"load_avg_1min":2.87,"mem_max_rss":24899584,"runnable_threads":3,"uptime":202510.2905125618},"values":[8.810541504544745e-06,8.662275341464465e-06,8.604520898813916e-06],"warmups":[[1024,8.845226562925746e-06]]},{"metadata":{"cpu_freq":"0=4983 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:37.073069","duration":0.7225551029841881,"load_avg_1min":2.87,"mem_max_rss":24838144,"runnable_threads":4,"uptime":202511.0746099949},"values":[8.734264257270752e-06,8.683997118907883e-06,8.701782617492881e-06],"warmups":[[1024,8.651253662605995e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=70 C, coretemp:Core 0=70 C","date":"2026-04-17 14:42:37.851256","duration":0.7167181780096143,"load_avg_1min":2.72,"mem_max_rss":24838144,"runnable_threads":2,"uptime":202511.85305142403},"values":[8.60825229551665e-06,8.730939893553113e-06,8.516901806387977e-06],"warmups":[[1024,8.628132471244499e-06]]},{"metadata":{"cpu_freq":"0=5083 MHz","cpu_temp":"coretemp:Package id 0=70 C, coretemp:Core 0=70 C","date":"2026-04-17 14:42:38.612442","duration":0.7007401669980027,"load_avg_1min":2.72,"mem_max_rss":25030656,"runnable_threads":4,"uptime":202512.6142692566},"values":[8.427441406411162e-06,8.405777928999215e-06,8.40309853629151e-06],"warmups":[[1024,8.451964453115579e-06]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:39.397812","duration":0.7235591979988385,"load_avg_1min":2.72,"mem_max_rss":24854528,"runnable_threads":2,"uptime":202513.39969682693},"values":[8.7010615715144e-06,8.564814990563718e-06,8.642706544037537e-06],"warmups":[[1024,8.88671992242962e-06]]},{"metadata":{"cpu_freq":"0=5066 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:40.179639","duration":0.7179898959875572,"load_avg_1min":2.72,"mem_max_rss":24838144,"runnable_threads":1,"uptime":202514.18135261536},"values":[8.644150830150465e-06,8.641890772764782e-06,8.643303222299891e-06],"warmups":[[1024,8.616524463889164e-06]]},{"metadata":{"cpu_freq":"0=5065 MHz","cpu_temp":"coretemp:Package id 0=68 C, coretemp:Core 0=68 C","date":"2026-04-17 14:42:40.960521","duration":0.7204134700004943,"load_avg_1min":2.72,"mem_max_rss":24838144,"runnable_threads":1,"uptime":202514.96233677864},"values":[8.650531104592573e-06,8.663640136319372e-06,8.656079785396287e-06],"warmups":[[1024,8.689589454036194e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=68 C, coretemp:Core 0=68 C","date":"2026-04-17 14:42:41.736249","duration":0.7150205470097717,"load_avg_1min":2.72,"mem_max_rss":24838144,"runnable_threads":2,"uptime":202515.73805356026},"values":[8.586893846995735e-06,8.528399023077782e-06,8.674305077249755e-06],"warmups":[[1024,8.593710107618336e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=71 C, coretemp:Core 0=63 C","date":"2026-04-17 14:42:42.539023","duration":0.7401059189869557,"load_avg_1min":2.58,"mem_max_rss":24920064,"runnable_threads":3,"uptime":202516.54089164734},"values":[8.883200732157092e-06,8.853291845412059e-06,8.905002978565335e-06],"warmups":[[1024,8.976740137711658e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=71 C, coretemp:Core 0=63 C","date":"2026-04-17 14:42:43.324101","duration":0.7221868839988019,"load_avg_1min":2.58,"mem_max_rss":24854528,"runnable_threads":2,"uptime":202517.32592272758},"values":[8.63520678677787e-06,8.619862011016722e-06,8.64528134769671e-06],"warmups":[[1024,8.834730175522055e-06]]}]},{"metadata":{"description":"Test the performance of pickling.","inner_loops":10,"loops":4096,"name":"unpickle_list","pickle_module":"pickle","pickle_protocol":"5","python_cflags":"-fno-strict-overflow -Wsign-compare -DNDEBUG -g -O3 -Wall","python_compiler":"GCC 15.2.0","python_config_args":"'--prefix=/tmp/cpython-build-baseline'","python_executable":"/home/mjbommar/src/cpython/venv/cpython3.15-97bec89492cb-compat-31b33d68c68a/bin/python","python_implementation":"cpython","python_version":"3.15.0a8+ (64-bit) revision 2faceeec5c0","tags":["serialize"],"timer":"clock_gettime(CLOCK_MONOTONIC), resolution: 1.00 ns"},"runs":[{"metadata":{"calibrate_loops":4096,"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=74 C, coretemp:Core 0=74 C","date":"2026-04-17 14:42:44.003179","duration":0.5550313419953454,"load_avg_1min":2.58,"mem_max_rss":24694784,"runnable_threads":1,"uptime":202518.00505948067},"warmups":[[1,3.353998181410134e-06],[2,2.6743000489659607e-06],[4,2.626675268402323e-06],[8,2.600187508505769e-06],[16,2.7299687644699588e-06],[32,2.608090653666295e-06],[64,2.6117515517398717e-06],[128,2.621322664708714e-06],[256,2.6189499976680964e-06],[512,2.6250582038755963e-06],[1024,2.632064649787935e-06],[2048,2.6550843756467655e-06],[4096,2.6961747067844042e-06],[4096,2.6505484619576692e-06],[4096,2.634413330326879e-06],[4096,2.657277612172493e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=74 C, coretemp:Core 0=74 C","date":"2026-04-17 14:42:44.516091","duration":0.4480043640069198,"load_avg_1min":2.58,"mem_max_rss":24813568,"runnable_threads":2,"uptime":202518.51788687706},"values":[2.657890527757445e-06,2.656174194015648e-06,2.7063917478642454e-06],"warmups":[[4096,2.657837524822071e-06]]},{"metadata":{"cpu_freq":"0=5079 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:45.021103","duration":0.44266953199985437,"load_avg_1min":2.58,"mem_max_rss":24915968,"runnable_threads":1,"uptime":202519.02288246155},"values":[2.643857958872786e-06,2.6244296627453425e-06,2.6288553222286738e-06],"warmups":[[4096,2.653570044230946e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:45.532750","duration":0.44795435800915584,"load_avg_1min":2.58,"mem_max_rss":24907776,"runnable_threads":1,"uptime":202519.53463053703},"values":[2.6728894773953015e-06,2.67802185049959e-06,2.6760498052169624e-06],"warmups":[[4096,2.6509440182564957e-06]]},{"metadata":{"cpu_freq":"0=4964 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:42:46.034944","duration":0.44024479799554683,"load_avg_1min":2.58,"mem_max_rss":24838144,"runnable_threads":2,"uptime":202520.03687524796},"values":[2.6223885498666277e-06,2.596986328029516e-06,2.6080033201481e-06],"warmups":[[4096,2.6575060545042105e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:42:46.543306","duration":0.44423989800270647,"load_avg_1min":2.58,"mem_max_rss":24850432,"runnable_threads":2,"uptime":202520.54512405396},"values":[2.6475631102584883e-06,2.6535065423161088e-06,2.6319707515654045e-06],"warmups":[[4096,2.643416674885657e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=64 C","date":"2026-04-17 14:42:47.050390","duration":0.4444500079844147,"load_avg_1min":2.58,"mem_max_rss":24883200,"runnable_threads":5,"uptime":202521.0522441864},"values":[2.6480842528542325e-06,2.6264116698371255e-06,2.624472534051847e-06],"warmups":[[4096,2.6803492190197176e-06]]},{"metadata":{"cpu_freq":"0=4938 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=64 C","date":"2026-04-17 14:42:47.564089","duration":0.4497376850049477,"load_avg_1min":2.45,"mem_max_rss":24735744,"runnable_threads":2,"uptime":202521.56598424911},"values":[2.6780613772814375e-06,2.696076196428976e-06,2.6679597660006493e-06],"warmups":[[4096,2.6698802244595754e-06]]},{"metadata":{"cpu_freq":"0=4982 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:42:48.075423","duration":0.44897271899390034,"load_avg_1min":2.45,"mem_max_rss":24719360,"runnable_threads":3,"uptime":202522.07702445984},"values":[2.656209936446885e-06,2.6801170413648377e-06,2.6728956790122993e-06],"warmups":[[4096,2.698148828272906e-06]]},{"metadata":{"cpu_freq":"0=4924 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:42:48.585490","duration":0.4564842779946048,"load_avg_1min":2.45,"mem_max_rss":24809472,"runnable_threads":2,"uptime":202522.59009742737},"values":[2.648062890386882e-06,2.628019971240292e-06,2.7390147216976857e-06],"warmups":[[4096,2.657927490190559e-06]]},{"metadata":{"cpu_freq":"0=5079 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:42:49.107897","duration":0.4490954579960089,"load_avg_1min":2.45,"mem_max_rss":25026560,"runnable_threads":2,"uptime":202523.10966730118},"values":[2.6766937253341894e-06,2.6862379634451374e-06,2.6799855227466197e-06],"warmups":[[4096,2.6567339844518755e-06]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:42:49.618553","duration":0.45007290301145986,"load_avg_1min":2.45,"mem_max_rss":25120768,"runnable_threads":3,"uptime":202523.6206767559},"values":[2.6350170656996854e-06,2.6997281736385046e-06,2.7185287841291485e-06],"warmups":[[4096,2.6501096925812817e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:50.134070","duration":0.44529122702078894,"load_avg_1min":2.45,"mem_max_rss":24858624,"runnable_threads":1,"uptime":202524.1357767582},"values":[2.651619775662084e-06,2.6303702881591563e-06,2.6364683591850735e-06],"warmups":[[4096,2.6986313230281665e-06]]},{"metadata":{"cpu_freq":"0=4896 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:50.642001","duration":0.445702055003494,"load_avg_1min":2.45,"mem_max_rss":25042944,"runnable_threads":2,"uptime":202524.6438548565},"values":[2.664274634156527e-06,2.6548002686865855e-06,2.6559508299328627e-06],"warmups":[[4096,2.632416894243761e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:42:51.153782","duration":0.4473450200166553,"load_avg_1min":2.45,"mem_max_rss":24858624,"runnable_threads":2,"uptime":202525.15555644035},"values":[2.6966565918939977e-06,2.6512643799492253e-06,2.637888037071434e-06],"warmups":[[4096,2.6786836670567025e-06]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:42:51.653585","duration":0.4390237649786286,"load_avg_1min":2.45,"mem_max_rss":25030656,"runnable_threads":2,"uptime":202525.65538692474},"values":[2.595985571218762e-06,2.5972619873471102e-06,2.6242374026708147e-06],"warmups":[[4096,2.641394237912209e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:42:52.163643","duration":0.447100118995877,"load_avg_1min":2.45,"mem_max_rss":24842240,"runnable_threads":1,"uptime":202526.16537332535},"values":[2.6498858886725428e-06,2.6771550778903476e-06,2.6542313719346567e-06],"warmups":[[4096,2.6783994876211636e-06]]},{"metadata":{"cpu_freq":"0=5013 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:42:52.674394","duration":0.45014137800899334,"load_avg_1min":2.34,"mem_max_rss":24768512,"runnable_threads":2,"uptime":202526.67620754242},"values":[2.6681881351464655e-06,2.6764893064523678e-06,2.687021362390851e-06],"warmups":[[4096,2.690525781190445e-06]]},{"metadata":{"cpu_freq":"0=5084 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:42:53.176685","duration":0.43912395599181764,"load_avg_1min":2.34,"mem_max_rss":24944640,"runnable_threads":1,"uptime":202527.17843556404},"values":[2.608063525144644e-06,2.603603466866389e-06,2.621882715203583e-06],"warmups":[[4096,2.626165454699958e-06]]},{"metadata":{"cpu_freq":"0=5069 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:42:53.685857","duration":0.4466307139955461,"load_avg_1min":2.34,"mem_max_rss":24801280,"runnable_threads":1,"uptime":202527.68766641617},"values":[2.6562048340394993e-06,2.647805859368191e-06,2.6815611569475097e-06],"warmups":[[4096,2.6514819090550646e-06]]},{"metadata":{"cpu_freq":"0=5077 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:42:54.190803","duration":0.44269304399495013,"load_avg_1min":2.34,"mem_max_rss":24895488,"runnable_threads":1,"uptime":202528.19257998466},"values":[2.6444590822904957e-06,2.6467949709285675e-06,2.6198111811481796e-06],"warmups":[[4096,2.6415601809048893e-06]]}]},{"metadata":{"description":"Test the performance of pickling.","inner_loops":20,"loops":64,"name":"unpickle_pure_python","pickle_module":"pickle","pickle_protocol":"5","python_cflags":"-fno-strict-overflow -Wsign-compare -DNDEBUG -g -O3 -Wall","python_compiler":"GCC 15.2.0","python_config_args":"'--prefix=/tmp/cpython-build-baseline'","python_executable":"/home/mjbommar/src/cpython/venv/cpython3.15-97bec89492cb-compat-31b33d68c68a/bin/python","python_implementation":"cpython","python_version":"3.15.0a8+ (64-bit) revision 2faceeec5c0","tags":["serialize"],"timer":"clock_gettime(CLOCK_MONOTONIC), resolution: 1.00 ns"},"runs":[{"metadata":{"calibrate_loops":64,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:42:55.113050","duration":0.7965219100005925,"load_avg_1min":2.34,"mem_max_rss":24788992,"runnable_threads":2,"uptime":202529.11483979225},"warmups":[[1,0.0001244566999957897],[2,0.00011867792491102592],[4,0.00011904537495865952],[8,0.00011954861874983181],[16,0.00011963236556766788],[32,0.00012113826878703548],[64,0.00012507611484124936],[64,0.0001252765742265183],[64,0.00012195106094168296],[64,0.00012143055078013276]]},{"metadata":{"cpu_freq":"0=5084 MHz","cpu_temp":"coretemp:Package id 0=79 C, coretemp:Core 0=79 C","date":"2026-04-17 14:42:55.810382","duration":0.6333487879892346,"load_avg_1min":2.34,"mem_max_rss":24948736,"runnable_threads":1,"uptime":202529.81221985817},"values":[0.00012108782811992569,0.00012100467733944242,0.0001228874054731932],"warmups":[[64,0.0001208634476597581]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=79 C, coretemp:Core 0=79 C","date":"2026-04-17 14:42:56.502537","duration":0.6292611960088834,"load_avg_1min":2.34,"mem_max_rss":24707072,"runnable_threads":1,"uptime":202530.50433516502},"values":[0.00012143318983817152,0.00012047282343701227,0.00012050603750139999],"warmups":[[64,0.00012025199453091773]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:57.197683","duration":0.6326557169959415,"load_avg_1min":2.34,"mem_max_rss":24772608,"runnable_threads":3,"uptime":202531.19955062866},"values":[0.0001209628414017061,0.00012127532186241296,0.00012109434062494984],"warmups":[[64,0.00012197057030789437]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:57.896978","duration":0.6378898760012817,"load_avg_1min":2.31,"mem_max_rss":24711168,"runnable_threads":2,"uptime":202531.89879274368},"values":[0.00012275446172225202,0.00012365515701731055,0.00012213572422297146],"warmups":[[64,0.00012029909764805779]]},{"metadata":{"cpu_freq":"0=4972 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:58.595037","duration":0.6353811610024422,"load_avg_1min":2.31,"mem_max_rss":25055232,"runnable_threads":2,"uptime":202532.59691238403},"values":[0.00012173275390523486,0.00012117118360492896,0.00012155461326983641],"warmups":[[64,0.00012248614141299185]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:42:59.293175","duration":0.6346776800055522,"load_avg_1min":2.31,"mem_max_rss":24686592,"runnable_threads":1,"uptime":202533.29501366615},"values":[0.00012128515704716847,0.00012130058203183581,0.00012175220936114784],"warmups":[[64,0.00012253791094281042]]},{"metadata":{"cpu_freq":"0=4958 MHz","cpu_temp":"coretemp:Package id 0=73 C, coretemp:Core 0=73 C","date":"2026-04-17 14:43:00.000260","duration":0.644394040980842,"load_avg_1min":2.31,"mem_max_rss":24645632,"runnable_threads":1,"uptime":202534.00209331512},"values":[0.00012804362422684789,0.0001226622734520788,0.00012217528594646865],"warmups":[[64,0.00012158116248883744]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:00.693587","duration":0.6311442310106941,"load_avg_1min":2.31,"mem_max_rss":24854528,"runnable_threads":1,"uptime":202534.6953613758},"values":[0.00012074155936261377,0.00012114625546928437,0.00012148112423346902],"warmups":[[64,0.00012054513983912329]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:01.381337","duration":0.6251369229867123,"load_avg_1min":2.31,"mem_max_rss":24674304,"runnable_threads":1,"uptime":202535.38306307793},"values":[0.00011961936170337139,0.00011982344217358332,0.0001198193984464524],"warmups":[[64,0.0001202610914106117]]},{"metadata":{"cpu_freq":"0=4982 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:43:02.065851","duration":0.6248108439904172,"load_avg_1min":2.31,"mem_max_rss":24850432,"runnable_threads":2,"uptime":202536.06745052338},"values":[0.00011971971719049179,0.0001191103914152336,0.00012124417578434077],"warmups":[[64,0.00011926535078146116]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:43:02.754044","duration":0.6271102270111442,"load_avg_1min":2.2,"mem_max_rss":24776704,"runnable_threads":1,"uptime":202536.75579428673},"values":[0.00011951852266065544,0.00012090614375210862,0.00012002154062429327],"warmups":[[64,0.00012046622889556602]]},{"metadata":{"cpu_freq":"0=4902 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:43:03.451304","duration":0.6334714359836653,"load_avg_1min":2.2,"mem_max_rss":25042944,"runnable_threads":3,"uptime":202537.45319151878},"values":[0.00012159210546087706,0.00011954984454405348,0.00012008990468075354],"warmups":[[64,0.0001243734507852423]]},{"metadata":{"cpu_freq":"0=5034 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:43:04.141503","duration":0.627543823007727,"load_avg_1min":2.2,"mem_max_rss":24846336,"runnable_threads":1,"uptime":202538.14315748215},"values":[0.00012035042891511694,0.00012040250389873108,0.00012013762029710051],"warmups":[[64,0.0001206969593795293]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:43:04.831372","duration":0.6305209109850693,"load_avg_1min":2.2,"mem_max_rss":24686592,"runnable_threads":1,"uptime":202538.8331515789},"values":[0.00012063561407558155,0.00012078950155682832,0.00012090417576473555],"warmups":[[64,0.00012118743829887535]]},{"metadata":{"cpu_freq":"0=5074 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:43:05.524543","duration":0.6324471660191193,"load_avg_1min":2.2,"mem_max_rss":24875008,"runnable_threads":1,"uptime":202539.52637648582},"values":[0.00012108615158012981,0.00012089536094208597,0.00012239537265941182],"warmups":[[64,0.00012071566327449545]]},{"metadata":{"cpu_freq":"0=5083 MHz","cpu_temp":"coretemp:Package id 0=70 C, coretemp:Core 0=70 C","date":"2026-04-17 14:43:06.216539","duration":0.6306148059957195,"load_avg_1min":2.2,"mem_max_rss":24846336,"runnable_threads":1,"uptime":202540.2182817459},"values":[0.0001209150546856108,0.00012134070234424144,0.00012120984297325776],"warmups":[[64,0.00012022336875361361]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=70 C, coretemp:Core 0=70 C","date":"2026-04-17 14:43:06.911236","duration":0.6346962609968614,"load_avg_1min":2.2,"mem_max_rss":24780800,"runnable_threads":1,"uptime":202540.91303563118},"values":[0.00012142187579229357,0.0001223454218916231,0.00012210717266043504],"warmups":[[64,0.00012106560157008062]]},{"metadata":{"cpu_freq":"0=5082 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:43:07.629589","duration":0.6579523390100803,"load_avg_1min":2.11,"mem_max_rss":24846336,"runnable_threads":1,"uptime":202541.63133645058},"values":[0.00014034255782462423,0.00012171552655217965,0.00012139997188569396],"warmups":[[64,0.00012139558905346348]]},{"metadata":{"cpu_freq":"0=5083 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:43:08.321471","duration":0.6291572390182409,"load_avg_1min":2.11,"mem_max_rss":24739840,"runnable_threads":2,"uptime":202542.3232076168},"values":[0.00012202541561237012,0.00012074281016793975,0.00011882523358508479],"warmups":[[64,0.00012093452187400544]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:09.009516","duration":0.6280695729947183,"load_avg_1min":2.11,"mem_max_rss":24756224,"runnable_threads":1,"uptime":202543.0112402439},"values":[0.000121540318764346,0.00012077304374997766,0.00011969088905061653],"warmups":[[64,0.000119796628905533]]}]}],"metadata":{"aslr":"Full randomization","boot_time":"2026-04-15 06:27:26","cpu_affinity":"0","cpu_config":"0=driver:intel_pstate, intel_pstate:turbo, governor:powersave; idle:intel_idle","cpu_count":24,"cpu_model_name":"12th Gen Intel(R) Core(TM) i9-12900K","hostname":"server0","perf_version":"2.10.0","performance_version":"1.14.0","platform":"Linux-7.0.0-13-generic-x86_64-with-glibc2.43","unit":"second"},"version":"1.0"} diff --git a/Misc/marshal-perf-data/pyperf-slice-current.json b/Misc/marshal-perf-data/pyperf-slice-current.json new file mode 100644 index 00000000000000..dabf83bdec2a16 --- /dev/null +++ b/Misc/marshal-perf-data/pyperf-slice-current.json @@ -0,0 +1 @@ +{"benchmarks":[{"metadata":{"description":"Test the performance of pickling.","inner_loops":20,"loops":1024,"name":"pickle","pickle_module":"pickle","pickle_protocol":"5","python_cflags":"-fno-strict-overflow -Wsign-compare -DNDEBUG -g -O3 -Wall","python_compiler":"GCC 15.2.0","python_config_args":"'--prefix=/tmp/cpython-build'","python_executable":"/home/mjbommar/src/cpython/venv/cpython3.15-f4470862ed70-compat-31b33d68c68a/bin/python","python_implementation":"cpython","python_version":"3.15.0a8+ (64-bit) revision c5e6bb4335b","tags":["serialize"],"timer":"clock_gettime(CLOCK_MONOTONIC), resolution: 1.00 ns"},"runs":[{"metadata":{"calibrate_loops":1024,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=73 C, coretemp:Core 0=73 C","date":"2026-04-17 14:43:20.202096","duration":0.7307958620076533,"load_avg_1min":1.94,"mem_max_rss":24743936,"runnable_threads":2,"uptime":202554.20396733284},"warmups":[[1,8.247849473264069e-06],[2,6.990075053181499e-06],[4,6.94820009812247e-06],[8,6.951287468837109e-06],[16,6.9000937401142435e-06],[32,6.968764046177966e-06],[64,6.917942187101289e-06],[128,7.046076552796876e-06],[256,7.03014062537477e-06],[512,7.0888374011701675e-06],[1024,7.004348388761627e-06],[1024,7.084523778644325e-06],[1024,7.067286084350144e-06],[1024,6.960688867252429e-06]]},{"metadata":{"cpu_freq":"0=5084 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:20.850170","duration":0.586853627988603,"load_avg_1min":1.94,"mem_max_rss":24711168,"runnable_threads":1,"uptime":202554.85199952126},"values":[7.081410107900865e-06,7.026673779364501e-06,6.981192530020053e-06],"warmups":[[1024,7.073677294044955e-06]]},{"metadata":{"cpu_freq":"0=4999 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:21.493258","duration":0.5841633659729268,"load_avg_1min":1.94,"mem_max_rss":24743936,"runnable_threads":1,"uptime":202555.49504876137},"values":[7.0028957509293836e-06,6.972373242319918e-06,7.017863818248315e-06],"warmups":[[1024,7.022877586848608e-06]]},{"metadata":{"cpu_freq":"0=5052 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:22.147835","duration":0.5953038890147582,"load_avg_1min":1.94,"mem_max_rss":24711168,"runnable_threads":1,"uptime":202556.14962100983},"values":[7.0994281259118e-06,7.163461376080704e-06,7.1981580560986915e-06],"warmups":[[1024,7.112160595568184e-06]]},{"metadata":{"cpu_freq":"0=4965 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:22.797779","duration":0.5911215179949068,"load_avg_1min":1.94,"mem_max_rss":24780800,"runnable_threads":3,"uptime":202556.7996313572},"values":[7.0429385246484346e-06,7.02476059473156e-06,7.199072754815461e-06],"warmups":[[1024,7.096653027360844e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:43:23.443133","duration":0.5869279640028253,"load_avg_1min":1.94,"mem_max_rss":24711168,"runnable_threads":2,"uptime":202557.44491171837},"values":[7.118497656222189e-06,7.037340967031014e-06,7.031749657926412e-06],"warmups":[[1024,6.981427831931342e-06]]},{"metadata":{"cpu_freq":"0=5070 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:43:24.086794","duration":0.5864762230194174,"load_avg_1min":1.94,"mem_max_rss":24850432,"runnable_threads":2,"uptime":202558.08847928047},"values":[7.103502197480793e-06,7.031545067093248e-06,6.978434569759884e-06],"warmups":[[1024,7.039283300969146e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:43:24.739504","duration":0.5936777940078173,"load_avg_1min":1.94,"mem_max_rss":24711168,"runnable_threads":1,"uptime":202558.74125528336},"values":[7.084359472742107e-06,7.093313720929473e-06,7.18458071276018e-06],"warmups":[[1024,7.1191460449426815e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:43:25.381612","duration":0.5828369329974521,"load_avg_1min":1.94,"mem_max_rss":24711168,"runnable_threads":2,"uptime":202559.38340377808},"values":[6.992290576590676e-06,6.915675830043711e-06,7.03278706026822e-06],"warmups":[[1024,7.025968456275677e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:43:26.024457","duration":0.5851180400059093,"load_avg_1min":1.94,"mem_max_rss":24715264,"runnable_threads":2,"uptime":202560.02626156807},"values":[7.039808495790112e-06,7.007052295193716e-06,7.059624950045418e-06],"warmups":[[1024,6.967609179753253e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:43:26.675104","duration":0.5893048600119073,"load_avg_1min":1.94,"mem_max_rss":24743936,"runnable_threads":1,"uptime":202560.67692494392},"values":[7.084611621621662e-06,7.066460790383644e-06,7.058403612347775e-06],"warmups":[[1024,7.062776219868283e-06]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:27.322925","duration":0.5907791760109831,"load_avg_1min":1.94,"mem_max_rss":24723456,"runnable_threads":2,"uptime":202561.32478308678},"values":[7.140636718361293e-06,7.015150488598465e-06,7.114170995237146e-06],"warmups":[[1024,7.072764257998187e-06]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:27.971895","duration":0.5909961919824127,"load_avg_1min":1.87,"mem_max_rss":24854528,"runnable_threads":2,"uptime":202561.97375035286},"values":[7.0941207994223985e-06,7.127265527628879e-06,7.075813915946583e-06],"warmups":[[1024,7.050082422210835e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:43:28.620485","duration":0.5905615299998317,"load_avg_1min":1.87,"mem_max_rss":24711168,"runnable_threads":2,"uptime":202562.62223768234},"values":[7.021979931209898e-06,7.116801953088725e-06,7.0524870125154845e-06],"warmups":[[1024,7.142571875817794e-06]]},{"metadata":{"cpu_freq":"0=4984 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:43:29.271791","duration":0.5927645929914434,"load_avg_1min":1.87,"mem_max_rss":24711168,"runnable_threads":1,"uptime":202563.27362418175},"values":[7.0479338873497e-06,7.11487167990299e-06,7.152868116122591e-06],"warmups":[[1024,7.127455712918618e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=74 C, coretemp:Core 0=74 C","date":"2026-04-17 14:43:29.918077","duration":0.5879289979930036,"load_avg_1min":1.87,"mem_max_rss":24711168,"runnable_threads":2,"uptime":202563.9199039936},"values":[7.070741112613632e-06,7.02542387784888e-06,7.132808593723894e-06],"warmups":[[1024,6.972631689450282e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=74 C, coretemp:Core 0=74 C","date":"2026-04-17 14:43:30.570135","duration":0.5921272819978185,"load_avg_1min":1.87,"mem_max_rss":24760320,"runnable_threads":1,"uptime":202564.5718767643},"values":[7.241920019396275e-06,7.088167578217508e-06,6.967857959239154e-06],"warmups":[[1024,7.115654541678396e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=68 C, coretemp:Core 0=68 C","date":"2026-04-17 14:43:31.209586","duration":0.5791899000178091,"load_avg_1min":1.87,"mem_max_rss":24711168,"runnable_threads":2,"uptime":202565.21133875847},"values":[6.894961231296293e-06,6.939459571242424e-06,6.95427885659683e-06],"warmups":[[1024,7.004237890839704e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=68 C, coretemp:Core 0=68 C","date":"2026-04-17 14:43:31.852688","duration":0.5844530889880843,"load_avg_1min":1.87,"mem_max_rss":24784896,"runnable_threads":2,"uptime":202565.85444188118},"values":[6.9920529796263505e-06,6.996456590968592e-06,7.0519014656156285e-06],"warmups":[[1024,7.004710742819498e-06]]},{"metadata":{"cpu_freq":"0=4967 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:43:32.502044","duration":0.5907751759805251,"load_avg_1min":1.87,"mem_max_rss":24711168,"runnable_threads":2,"uptime":202566.50390982628},"values":[7.075453954996647e-06,7.090814892762864e-06,7.055210204498508e-06],"warmups":[[1024,7.117904981157608e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:43:33.143969","duration":0.5832241720054299,"load_avg_1min":1.96,"mem_max_rss":24711168,"runnable_threads":2,"uptime":202567.14577770233},"values":[6.933516992546629e-06,7.018917480650089e-06,7.011284375835203e-06],"warmups":[[1024,7.008829784638238e-06]]}]},{"metadata":{"description":"Test the performance of pickling.","inner_loops":5,"loops":2048,"name":"pickle_dict","pickle_module":"pickle","pickle_protocol":"5","python_cflags":"-fno-strict-overflow -Wsign-compare -DNDEBUG -g -O3 -Wall","python_compiler":"GCC 15.2.0","python_config_args":"'--prefix=/tmp/cpython-build'","python_executable":"/home/mjbommar/src/cpython/venv/cpython3.15-f4470862ed70-compat-31b33d68c68a/bin/python","python_implementation":"cpython","python_version":"3.15.0a8+ (64-bit) revision c5e6bb4335b","tags":["serialize"],"timer":"clock_gettime(CLOCK_MONOTONIC), resolution: 1.00 ns"},"runs":[{"metadata":{"calibrate_loops":2048,"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=77 C, coretemp:Core 0=77 C","date":"2026-04-17 14:43:34.116746","duration":0.8511427469784394,"load_avg_1min":1.96,"mem_max_rss":24686592,"runnable_threads":2,"uptime":202568.11854076385},"warmups":[[1,1.772260293364525e-05],[2,1.651469792705029e-05],[4,1.653219951549545e-05],[8,1.6584074910497292e-05],[16,1.6647812662995422e-05],[32,1.646049986447906e-05],[64,1.6826268711156446e-05],[128,1.6578382837906246e-05],[256,1.664312264892942e-05],[512,1.6375074994812167e-05],[1024,1.673745761650025e-05],[2048,1.6495602832833355e-05],[2048,1.6345133300887937e-05],[2048,1.6327803712101742e-05],[2048,1.6316903221991196e-05]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:43:34.878279","duration":0.7010054800193757,"load_avg_1min":1.96,"mem_max_rss":24793088,"runnable_threads":4,"uptime":202568.88016700745},"values":[1.6445974412704346e-05,1.801917900365879e-05,1.6427096389293185e-05],"warmups":[[2048,1.6550177051044557e-05]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:43:35.624199","duration":0.6865526309993584,"load_avg_1min":1.96,"mem_max_rss":24793088,"runnable_threads":2,"uptime":202569.62601304054},"values":[1.6531866015156994e-05,1.6605279685677488e-05,1.6526565428875983e-05],"warmups":[[2048,1.639907880814917e-05]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:43:36.372184","duration":0.687614324997412,"load_avg_1min":1.96,"mem_max_rss":24793088,"runnable_threads":1,"uptime":202570.37404108047},"values":[1.654932089820704e-05,1.6534415723867824e-05,1.6560373731522303e-05],"warmups":[[2048,1.6474413087053108e-05]]},{"metadata":{"cpu_freq":"0=4946 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:43:37.126635","duration":0.6945811919867992,"load_avg_1min":1.96,"mem_max_rss":24858624,"runnable_threads":2,"uptime":202571.12850356102},"values":[1.6712576172039918e-05,1.6692415428565255e-05,1.6704803124412136e-05],"warmups":[[2048,1.670511454960888e-05]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=82 C, coretemp:Core 0=82 C","date":"2026-04-17 14:43:37.866219","duration":0.6804061629809439,"load_avg_1min":1.88,"mem_max_rss":24793088,"runnable_threads":1,"uptime":202571.8680114746},"values":[1.6336450096332554e-05,1.6300302246463615e-05,1.6423514747998524e-05],"warmups":[[2048,1.6375691893699694e-05]]},{"metadata":{"cpu_freq":"0=5080 MHz","cpu_temp":"coretemp:Package id 0=82 C, coretemp:Core 0=82 C","date":"2026-04-17 14:43:38.609117","duration":0.683917004003888,"load_avg_1min":1.88,"mem_max_rss":24793088,"runnable_threads":1,"uptime":202572.61091017723},"values":[1.6520071582704077e-05,1.656997578152186e-05,1.6217682909314134e-05],"warmups":[[2048,1.6439168163628892e-05]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=68 C, coretemp:Core 0=68 C","date":"2026-04-17 14:43:39.342110","duration":0.674758851993829,"load_avg_1min":1.88,"mem_max_rss":24793088,"runnable_threads":1,"uptime":202573.34394311905},"values":[1.6301414353847578e-05,1.6212038184448828e-05,1.6172947167092388e-05],"warmups":[[2048,1.6198591211491475e-05]]},{"metadata":{"cpu_freq":"0=5066 MHz","cpu_temp":"coretemp:Package id 0=68 C, coretemp:Core 0=68 C","date":"2026-04-17 14:43:40.088049","duration":0.6868126280023716,"load_avg_1min":1.88,"mem_max_rss":24793088,"runnable_threads":3,"uptime":202574.0895819664},"values":[1.657005537083478e-05,1.6340217186439077e-05,1.630394746143793e-05],"warmups":[[2048,1.6882199511769612e-05]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=68 C, coretemp:Core 0=68 C","date":"2026-04-17 14:43:40.831223","duration":0.6836407989903819,"load_avg_1min":1.88,"mem_max_rss":24809472,"runnable_threads":1,"uptime":202574.8331000805},"values":[1.6637317284562413e-05,1.633972226500191e-05,1.64130081031999e-05],"warmups":[[2048,1.636699033156219e-05]]},{"metadata":{"cpu_freq":"0=5016 MHz","cpu_temp":"coretemp:Package id 0=68 C, coretemp:Core 0=68 C","date":"2026-04-17 14:43:41.576724","duration":0.6869130140112247,"load_avg_1min":1.88,"mem_max_rss":24793088,"runnable_threads":2,"uptime":202575.5785369873},"values":[1.6633151463452123e-05,1.653802451073716e-05,1.6320025000027272e-05],"warmups":[[2048,1.6580431642410075e-05]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:43:42.322740","duration":0.6862790310115088,"load_avg_1min":1.88,"mem_max_rss":24793088,"runnable_threads":1,"uptime":202576.32453656197},"values":[1.643818847867351e-05,1.6517657519443675e-05,1.665827558667843e-05],"warmups":[[2048,1.642048896428605e-05]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:43:43.063625","duration":0.6827668100013398,"load_avg_1min":1.89,"mem_max_rss":24793088,"runnable_threads":4,"uptime":202577.06527733803},"values":[1.643519589720199e-05,1.639182812311901e-05,1.6398851172994e-05],"warmups":[[2048,1.641657226514326e-05]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=78 C, coretemp:Core 0=78 C","date":"2026-04-17 14:43:43.811838","duration":0.6878741540131159,"load_avg_1min":1.89,"mem_max_rss":24793088,"runnable_threads":2,"uptime":202577.81363105774},"values":[1.6762160154826233e-05,1.6559236524926745e-05,1.6447040528078106e-05],"warmups":[[2048,1.6412422655776027e-05]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=78 C, coretemp:Core 0=78 C","date":"2026-04-17 14:43:44.552510","duration":0.6803183809970506,"load_avg_1min":1.89,"mem_max_rss":24793088,"runnable_threads":1,"uptime":202578.55428934097},"values":[1.625067890529408e-05,1.6462144432694004e-05,1.6187810936685308e-05],"warmups":[[2048,1.6537059082111227e-05]]},{"metadata":{"cpu_freq":"0=5007 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:43:45.289596","duration":0.6781545549747534,"load_avg_1min":1.89,"mem_max_rss":24801280,"runnable_threads":1,"uptime":202579.29138064384},"values":[1.6318494044753606e-05,1.6317743748572867e-05,1.6309642285250446e-05],"warmups":[[2048,1.6294382911041792e-05]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:43:46.033263","duration":0.6855705589987338,"load_avg_1min":1.89,"mem_max_rss":24793088,"runnable_threads":1,"uptime":202580.03505778313},"values":[1.6392532714348818e-05,1.6538956347744716e-05,1.6362811135195442e-05],"warmups":[[2048,1.6624096190298587e-05]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:43:46.772588","duration":0.6780720630194992,"load_avg_1min":1.89,"mem_max_rss":24809472,"runnable_threads":1,"uptime":202580.77436757088},"values":[1.6301209373636994e-05,1.6210155663998194e-05,1.631211728465587e-05],"warmups":[[2048,1.6403173242451884e-05]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:43:47.508802","duration":0.6778622099955101,"load_avg_1min":1.89,"mem_max_rss":24793088,"runnable_threads":1,"uptime":202581.5106101036},"values":[1.6324569432413228e-05,1.6163234766963798e-05,1.6405694432819472e-05],"warmups":[[2048,1.6289421873239006e-05]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:48.249710","duration":0.6828090290073305,"load_avg_1min":1.98,"mem_max_rss":24793088,"runnable_threads":1,"uptime":202582.25149011612},"values":[1.6410153514812008e-05,1.6533669142404506e-05,1.6306004494026637e-05],"warmups":[[2048,1.6424091990074884e-05]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:48.987844","duration":0.6782725529919844,"load_avg_1min":1.98,"mem_max_rss":24793088,"runnable_threads":2,"uptime":202582.9896659851},"values":[1.6242975976865637e-05,1.6254781445468325e-05,1.634245771526821e-05],"warmups":[[2048,1.6376885059798952e-05]]}]},{"metadata":{"description":"Test the performance of pickling.","inner_loops":10,"loops":4096,"name":"pickle_list","pickle_module":"pickle","pickle_protocol":"5","python_cflags":"-fno-strict-overflow -Wsign-compare -DNDEBUG -g -O3 -Wall","python_compiler":"GCC 15.2.0","python_config_args":"'--prefix=/tmp/cpython-build'","python_executable":"/home/mjbommar/src/cpython/venv/cpython3.15-f4470862ed70-compat-31b33d68c68a/bin/python","python_implementation":"cpython","python_version":"3.15.0a8+ (64-bit) revision c5e6bb4335b","tags":["serialize"],"timer":"clock_gettime(CLOCK_MONOTONIC), resolution: 1.00 ns"},"runs":[{"metadata":{"calibrate_loops":4096,"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:49.661091","duration":0.5503690509940498,"load_avg_1min":1.98,"mem_max_rss":24559616,"runnable_threads":2,"uptime":202583.66296505928},"warmups":[[1,3.3034011721611023e-06],[2,2.7176007279194892e-06],[4,2.6445501134730876e-06],[8,3.0311999580590055e-06],[16,2.561043766036164e-06],[32,2.5863031623885035e-06],[64,2.651593740665703e-06],[128,2.59885937339277e-06],[256,2.5902749939632486e-06],[512,2.5997599607308074e-06],[1024,2.6042186533459242e-06],[2048,2.636591747773309e-06],[4096,2.633630859349978e-06],[4096,2.6343367188985668e-06],[4096,2.639812792892826e-06],[4096,2.643324170037431e-06]]},{"metadata":{"cpu_freq":"0=5089 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:50.176896","duration":0.45350505999522284,"load_avg_1min":1.98,"mem_max_rss":24756224,"runnable_threads":1,"uptime":202584.1786980629},"values":[2.709329027794638e-06,2.70198259286758e-06,2.6961719967744102e-06],"warmups":[[4096,2.714824243099656e-06]]},{"metadata":{"cpu_freq":"0=5088 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:50.697732","duration":0.46029698799247853,"load_avg_1min":1.98,"mem_max_rss":24834048,"runnable_threads":1,"uptime":202584.69953656197},"values":[2.7671206787260872e-06,2.7240527096239475e-06,2.7406279052399894e-06],"warmups":[[4096,2.7552790527352046e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:51.209395","duration":0.45341961801750585,"load_avg_1min":1.98,"mem_max_rss":24797184,"runnable_threads":1,"uptime":202585.21123099327},"values":[2.699782079673696e-06,2.715753515758479e-06,2.6771350583487676e-06],"warmups":[[4096,2.7185746581892546e-06]]},{"metadata":{"cpu_freq":"0=5055 MHz","cpu_temp":"coretemp:Package id 0=78 C, coretemp:Core 0=78 C","date":"2026-04-17 14:43:51.729106","duration":0.458570654009236,"load_avg_1min":1.98,"mem_max_rss":24756224,"runnable_threads":1,"uptime":202585.73104000092},"values":[2.751701172343246e-06,2.7159213622951485e-06,2.7368434814434297e-06],"warmups":[[4096,2.7369611089511635e-06]]},{"metadata":{"cpu_freq":"0=4985 MHz","cpu_temp":"coretemp:Package id 0=78 C, coretemp:Core 0=78 C","date":"2026-04-17 14:43:52.228916","duration":0.4407742530165706,"load_avg_1min":1.98,"mem_max_rss":24784896,"runnable_threads":1,"uptime":202586.23073029518},"values":[2.633857324241262e-06,2.6362495361809122e-06,2.6059706051739794e-06],"warmups":[[4096,2.633525781448043e-06]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:43:52.738002","duration":0.44847984600346535,"load_avg_1min":1.9,"mem_max_rss":24780800,"runnable_threads":3,"uptime":202586.73986577988},"values":[2.6791614011756337e-06,2.677568823372667e-06,2.6610220707823372e-06],"warmups":[[4096,2.6790766362694283e-06]]},{"metadata":{"cpu_freq":"0=5083 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:43:53.236651","duration":0.440834951994475,"load_avg_1min":1.9,"mem_max_rss":24756224,"runnable_threads":1,"uptime":202587.23840236664},"values":[2.6019703611268595e-06,2.6380620120391995e-06,2.6345119870541113e-06],"warmups":[[4096,2.6407259760219405e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:53.745678","duration":0.4488650719868019,"load_avg_1min":1.9,"mem_max_rss":24756224,"runnable_threads":2,"uptime":202587.74742484093},"values":[2.6933499270853645e-06,2.667296337932612e-06,2.6719871335956215e-06],"warmups":[[4096,2.6820522215587062e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:54.247406","duration":0.4429974869999569,"load_avg_1min":1.9,"mem_max_rss":24756224,"runnable_threads":1,"uptime":202588.24922442436},"values":[2.6493993900089664e-06,2.656274609336151e-06,2.628836718798766e-06],"warmups":[[4096,2.6290145015650524e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=69 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:54.754766","duration":0.44860276201507077,"load_avg_1min":1.9,"mem_max_rss":24756224,"runnable_threads":2,"uptime":202588.756619215},"values":[2.6706771969031705e-06,2.679772681091208e-06,2.679096460411756e-06],"warmups":[[4096,2.6680962648129025e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=69 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:55.261515","duration":0.44771374101401307,"load_avg_1min":1.9,"mem_max_rss":24756224,"runnable_threads":2,"uptime":202589.26332330704},"values":[2.665545214597387e-06,2.6662790773457347e-06,2.69161296415632e-06],"warmups":[[4096,2.650297021489223e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:55.771343","duration":0.4505273480026517,"load_avg_1min":1.9,"mem_max_rss":24756224,"runnable_threads":1,"uptime":202589.7731089592},"values":[2.6762734620433547e-06,2.6675504393836034e-06,2.709764868313869e-06],"warmups":[[4096,2.6995399416307466e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:56.281777","duration":0.4518449250026606,"load_avg_1min":1.9,"mem_max_rss":24756224,"runnable_threads":1,"uptime":202590.28357076645},"values":[2.6772086179960296e-06,2.6998574945480413e-06,2.698931909606017e-06],"warmups":[[4096,2.7036522951107143e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:43:56.791182","duration":0.4497224609949626,"load_avg_1min":1.9,"mem_max_rss":24887296,"runnable_threads":2,"uptime":202590.79302740097},"values":[2.685805468871649e-06,2.67147961423575e-06,2.6756983643849706e-06],"warmups":[[4096,2.693412060494893e-06]]},{"metadata":{"cpu_freq":"0=5078 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:43:57.298279","duration":0.44910854898625985,"load_avg_1min":1.9,"mem_max_rss":24756224,"runnable_threads":1,"uptime":202591.3001074791},"values":[2.681409985427763e-06,2.658414795320141e-06,2.668531323024581e-06],"warmups":[[4096,2.699854540821889e-06]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:43:57.815228","duration":0.4580086380010471,"load_avg_1min":1.83,"mem_max_rss":24756224,"runnable_threads":2,"uptime":202591.81707668304},"values":[2.626764452884345e-06,2.6428182124504927e-06,3.0166978028489664e-06],"warmups":[[4096,2.645560571323813e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:43:58.318768","duration":0.4439271269948222,"load_avg_1min":1.83,"mem_max_rss":24756224,"runnable_threads":3,"uptime":202592.32063484192},"values":[2.6273451659619695e-06,2.637798901616861e-06,2.657262523797499e-06],"warmups":[[4096,2.659528686876911e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:58.832108","duration":0.45382729900302365,"load_avg_1min":1.83,"mem_max_rss":24797184,"runnable_threads":2,"uptime":202592.8339343071},"values":[2.7322148440589445e-06,2.7103018069851714e-06,2.697030956966273e-06],"warmups":[[4096,2.6905656007158994e-06]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:59.340442","duration":0.44971713999984786,"load_avg_1min":1.83,"mem_max_rss":24756224,"runnable_threads":2,"uptime":202593.3422703743},"values":[2.6659711181764577e-06,2.676298364434615e-06,2.692556860495188e-06],"warmups":[[4096,2.6820754392531397e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:43:59.841478","duration":0.4409144110104535,"load_avg_1min":1.83,"mem_max_rss":24756224,"runnable_threads":2,"uptime":202593.8432559967},"values":[2.6437449946570267e-06,2.637638989710922e-06,2.627271020827493e-06],"warmups":[[4096,2.609531103558993e-06]]}]},{"metadata":{"description":"Test the performance of pickling.","inner_loops":20,"loops":32,"name":"pickle_pure_python","pickle_module":"pickle","pickle_protocol":"5","python_cflags":"-fno-strict-overflow -Wsign-compare -DNDEBUG -g -O3 -Wall","python_compiler":"GCC 15.2.0","python_config_args":"'--prefix=/tmp/cpython-build'","python_executable":"/home/mjbommar/src/cpython/venv/cpython3.15-f4470862ed70-compat-31b33d68c68a/bin/python","python_implementation":"cpython","python_version":"3.15.0a8+ (64-bit) revision c5e6bb4335b","tags":["serialize"],"timer":"clock_gettime(CLOCK_MONOTONIC), resolution: 1.00 ns"},"runs":[{"metadata":{"calibrate_loops":32,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:44:00.565214","duration":0.6033144499815535,"load_avg_1min":1.83,"mem_max_rss":25731072,"runnable_threads":1,"uptime":202594.56715512276},"warmups":[[1,0.0001916430497658439],[2,0.00019396617499296555],[4,0.00018722457498370203],[8,0.0001857733061115141],[16,0.00018501992808523938],[32,0.00018595452816043688],[32,0.00018719315153248317],[32,0.00018676685936043215],[32,0.00018586354840408604]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:44:01.113641","duration":0.48717913302243687,"load_avg_1min":1.83,"mem_max_rss":25780224,"runnable_threads":3,"uptime":202595.1152896881},"values":[0.0001862822202838288,0.0001863771312400786,0.00018710617346187063],"warmups":[[32,0.00018578233907646792]]},{"metadata":{"cpu_freq":"0=4935 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:44:01.663758","duration":0.49042137400829233,"load_avg_1min":1.83,"mem_max_rss":25960448,"runnable_threads":2,"uptime":202595.6657295227},"values":[0.00018882525937442552,0.00018784082189995387,0.00018645581403688993],"warmups":[[32,0.00018678033752621558]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:44:02.208857","duration":0.48506530400482006,"load_avg_1min":1.83,"mem_max_rss":25800704,"runnable_threads":1,"uptime":202596.21067214012},"values":[0.00018623561718413839,0.00018575114218037924,0.00018362917185186234],"warmups":[[32,0.00018675461560633267]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:44:02.753203","duration":0.484404627000913,"load_avg_1min":1.76,"mem_max_rss":25776128,"runnable_threads":2,"uptime":202596.75514006615},"values":[0.00018605401096465356,0.0001843944796746655,0.00018615440003486584],"warmups":[[32,0.00018317585627301015]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:44:03.299140","duration":0.4847181049990468,"load_avg_1min":1.76,"mem_max_rss":25718784,"runnable_threads":1,"uptime":202597.30094003677},"values":[0.00018626703281370282,0.00018512929373173392,0.00018456558282196057],"warmups":[[32,0.00018516950003686362]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:44:03.845574","duration":0.4878975189931225,"load_avg_1min":1.76,"mem_max_rss":25788416,"runnable_threads":1,"uptime":202597.847397089},"values":[0.00018705859529291046,0.00018676127501748852,0.000184979706273225],"warmups":[[32,0.00018733701717792427]]},{"metadata":{"cpu_freq":"0=5083 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:44:04.406877","duration":0.5012710669834632,"load_avg_1min":1.76,"mem_max_rss":25882624,"runnable_threads":1,"uptime":202598.40867567062},"values":[0.000190985303152047,0.00019217735934944357,0.0001929854046920809],"warmups":[[32,0.00019128757498947379]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:44:04.955695","duration":0.4898226739896927,"load_avg_1min":1.76,"mem_max_rss":25890816,"runnable_threads":1,"uptime":202598.9575164318},"values":[0.0001882342640783463,0.00018857225782085152,0.00018742664533419884],"warmups":[[32,0.0001853021734405047]]},{"metadata":{"cpu_freq":"0=5092 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:44:05.509523","duration":0.4953010199824348,"load_avg_1min":1.76,"mem_max_rss":25886720,"runnable_threads":2,"uptime":202599.51134347916},"values":[0.000187293942190081,0.00018604539063744597,0.0001861420890691079],"warmups":[[32,0.00019823271873065096]]},{"metadata":{"cpu_freq":"0=4899 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:44:06.053157","duration":0.48357198399025947,"load_avg_1min":1.76,"mem_max_rss":25886720,"runnable_threads":3,"uptime":202600.05479502678},"values":[0.00018445470936967467,0.00018422898124299537,0.00018474377029633615],"warmups":[[32,0.00018669672808755423]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:44:06.599864","duration":0.48778456199215725,"load_avg_1min":1.76,"mem_max_rss":25796608,"runnable_threads":1,"uptime":202600.60165309906},"values":[0.0001875307312275254,0.00018594629063954925,0.00018616817342262948],"warmups":[[32,0.00018621597969286084]]},{"metadata":{"cpu_freq":"0=4004 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:44:07.154213","duration":0.503751590003958,"load_avg_1min":1.76,"mem_max_rss":25870336,"runnable_threads":4,"uptime":202601.1607747078},"values":[0.0001845906781454687,0.00018343878750783915,0.0002038925843862671],"warmups":[[32,0.00018414464375382522]]},{"metadata":{"cpu_freq":"0=5055 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:44:07.708174","duration":0.4846405030111782,"load_avg_1min":1.86,"mem_max_rss":25710592,"runnable_threads":1,"uptime":202601.7100057602},"values":[0.0001845357703132322,0.00018484114066268375,0.00018553367967797386],"warmups":[[32,0.00018647975934982242]]},{"metadata":{"cpu_freq":"0=5016 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:44:08.257309","duration":0.48871080702519976,"load_avg_1min":1.86,"mem_max_rss":25911296,"runnable_threads":1,"uptime":202602.2591292858},"values":[0.0001873974797035771,0.00018710785934672458,0.00018524102342780678],"warmups":[[32,0.000187885687500966]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:44:08.800256","duration":0.48411012298311107,"load_avg_1min":1.86,"mem_max_rss":25788416,"runnable_threads":2,"uptime":202602.80205512047},"values":[0.00018541045469646633,0.00018578228591650258,0.00018390132968306716],"warmups":[[32,0.00018505268590160995]]},{"metadata":{"cpu_freq":"0=5083 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:44:09.347472","duration":0.48804456600919366,"load_avg_1min":1.86,"mem_max_rss":25620480,"runnable_threads":1,"uptime":202603.34924030304},"values":[0.00018769362031889614,0.0001856402765497478,0.00018576502188807353],"warmups":[[32,0.0001876775343589543]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:44:09.891862","duration":0.48547824399429373,"load_avg_1min":1.86,"mem_max_rss":25952256,"runnable_threads":1,"uptime":202603.8936033249},"values":[0.00018539918746682816,0.0001876011093827401,0.00018551448279140458],"warmups":[[32,0.00018456230313859123]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:44:10.431507","duration":0.4810893720132299,"load_avg_1min":1.86,"mem_max_rss":25894912,"runnable_threads":2,"uptime":202604.43329310417},"values":[0.0001835533718804072,0.0001833580843594973,0.00018414460314488678],"warmups":[[32,0.0001847156171606912]]},{"metadata":{"cpu_freq":"0=4905 MHz","cpu_temp":"coretemp:Package id 0=62 C, coretemp:Core 0=62 C","date":"2026-04-17 14:44:10.973457","duration":0.48383858098532073,"load_avg_1min":1.86,"mem_max_rss":25923584,"runnable_threads":1,"uptime":202604.97527956963},"values":[0.00018349865936215793,0.00018555675937932393,0.00018737590626187738],"warmups":[[32,0.00018378294062131316]]},{"metadata":{"cpu_freq":"0=5043 MHz","cpu_temp":"coretemp:Package id 0=62 C, coretemp:Core 0=62 C","date":"2026-04-17 14:44:11.515421","duration":0.48276486701797694,"load_avg_1min":1.86,"mem_max_rss":25866240,"runnable_threads":3,"uptime":202605.5172791481},"values":[0.00018430540621920953,0.00018395288439023715,0.00018340561405238986],"warmups":[[32,0.00018664790936782084]]}]},{"metadata":{"command":"/home/mjbommar/src/cpython/venv/cpython3.15-f4470862ed70-compat-31b33d68c68a/bin/python -c pass","description":"Performance of the Python startup","loops":16,"name":"python_startup","tags":["startup"]},"runs":[{"metadata":{"calibrate_loops":16,"command_max_rss":16564224,"cpu_freq":"0=5016 MHz","cpu_temp":"coretemp:Package id 0=65 C, coretemp:Core 0=60 C","date":"2026-04-17 14:44:13.283693","duration":1.6447518909990322,"load_avg_1min":1.87,"runnable_threads":3,"uptime":202607.28527998924},"warmups":[[1,0.007789296010741964],[2,0.006996370502747595],[4,0.007036962248093914],[8,0.00719012312401901],[16,0.006863242688268656],[16,0.007229278875456657],[16,0.006815554374043131],[16,0.006842266373496386],[16,0.006896549937664531],[16,0.006821220375059056],[16,0.006883175748953363],[16,0.006982453312957659],[16,0.00676698624920391],[16,0.006945184937649174],[16,0.006794315311708488]]},{"metadata":{"command_max_rss":16592896,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=62 C, coretemp:Core 0=62 C","date":"2026-04-17 14:44:14.784403","duration":1.4443571160081774,"load_avg_1min":1.87,"runnable_threads":1,"uptime":202608.78591632843},"values":[0.006949114187591476,0.006999998875471647,0.006946737188627594,0.006751841188815888,0.00703120112484612,0.006815134685894009,0.006856168312879163,0.006688391562420293,0.006837663499027258,0.006771489186576218],"warmups":[[16,0.006875801187561592]]},{"metadata":{"command_max_rss":16621568,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:44:16.273049","duration":1.4307504769822117,"load_avg_1min":1.87,"runnable_threads":2,"uptime":202610.27460741997},"values":[0.0069633833118132316,0.006646235249718302,0.006783557686503627,0.006755370313840103,0.006703717561322264,0.006930000250576995,0.00669893193844473,0.006743053250829689,0.006879627500893548,0.006656005250988528],"warmups":[[16,0.00703499156225007]]},{"metadata":{"command_max_rss":16637952,"cpu_freq":"0=5083 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:44:17.760779","duration":1.4310621229815297,"load_avg_1min":1.88,"runnable_threads":2,"uptime":202611.76234221458},"values":[0.006798128499212908,0.006785916562876082,0.006667918125458527,0.006695717998809414,0.006960469250770984,0.006691523687550216,0.006832591061538551,0.006883696687509655,0.006712704313031281,0.006865664623546763],"warmups":[[16,0.0067379598131083185]]},{"metadata":{"command_max_rss":16527360,"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=60 C","date":"2026-04-17 14:44:19.247912","duration":1.428995780996047,"load_avg_1min":1.88,"runnable_threads":2,"uptime":202613.24949216843},"values":[0.006977656812523492,0.006571271624125075,0.006670559874692117,0.006774468874937156,0.0070268008748826105,0.006818909812864149,0.006822351875598542,0.00663352318770194,0.0068808738760708366,0.006599710313821561],"warmups":[[16,0.006881434062961489]]},{"metadata":{"command_max_rss":16650240,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:44:20.706388","duration":1.4018140670086723,"load_avg_1min":1.88,"runnable_threads":1,"uptime":202614.70790171623},"values":[0.006573911437953939,0.006670925000435091,0.0066871624385385076,0.006629125313338591,0.006944008124264656,0.006611172686461941,0.006580618437510566,0.006635986186665832,0.006614441314013675,0.0066948353760381],"warmups":[[16,0.00662712262601417]]},{"metadata":{"command_max_rss":16560128,"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:44:22.183653","duration":1.4099126190121751,"load_avg_1min":1.88,"runnable_threads":2,"uptime":202616.18522548676},"values":[0.006635068937612232,0.0067673016237677075,0.006600699562113732,0.006586278748727636,0.006565171437614481,0.006745373624653439,0.006736634188200696,0.006743251062289346,0.006891947061376413,0.006691590375339729],"warmups":[[16,0.006617123062824248]]},{"metadata":{"command_max_rss":16609280,"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:44:23.633519","duration":1.393847541010473,"load_avg_1min":1.89,"runnable_threads":2,"uptime":202617.63512420654},"values":[0.006560319689015159,0.006594120062800357,0.00656423400141648,0.006551187625518651,0.006572866188435,0.0068368741867743665,0.006531508062835201,0.006642355061558192,0.006588736001504003,0.006616351749471505],"warmups":[[16,0.0066547263759275666]]},{"metadata":{"command_max_rss":16654336,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=68 C, coretemp:Core 0=62 C","date":"2026-04-17 14:44:25.115945","duration":1.425798302021576,"load_avg_1min":1.89,"runnable_threads":2,"uptime":202619.11743664742},"values":[0.006751632812665775,0.006907466438860865,0.006602002562431153,0.006685446000119555,0.006773779625291354,0.006678260375338141,0.0068066669373365585,0.006838922376118717,0.0068433530013862764,0.006842918062829995],"warmups":[[16,0.006863434811748448]]},{"metadata":{"command_max_rss":16674816,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:44:26.578968","duration":1.4064704519987572,"load_avg_1min":1.89,"runnable_threads":1,"uptime":202620.5804567337},"values":[0.006607290624742745,0.006759557500117808,0.006700991874822648,0.00669300343724899,0.006648592061537784,0.006914286812389037,0.006571370999154169,0.00668038850017183,0.006693131874271785,0.006615542000872665],"warmups":[[16,0.006644051687544561]]},{"metadata":{"command_max_rss":16592896,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:44:28.034825","duration":1.3995552139822394,"load_avg_1min":1.9,"runnable_threads":4,"uptime":202622.03654408455},"values":[0.0067374076243140735,0.0067091716246068245,0.006806983250498888,0.006574359626029036,0.006581286001164699,0.0065444269366707886,0.006552593062224332,0.006636541187617695,0.006598329187909258,0.006635679375904147],"warmups":[[16,0.0066915862498717615]]},{"metadata":{"command_max_rss":16654336,"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=70 C, coretemp:Core 0=64 C","date":"2026-04-17 14:44:29.505193","duration":1.4111968179931864,"load_avg_1min":1.9,"runnable_threads":2,"uptime":202623.50678610802},"values":[0.006632139749854105,0.006582403624634026,0.00676996318725287,0.006775469999411143,0.006822641813414521,0.006642090687819291,0.006885541562951403,0.006578866561540053,0.006741074501405819,0.00667020893888548],"warmups":[[16,0.006586689687537728]]},{"metadata":{"command_max_rss":16617472,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:44:30.966585","duration":1.4045543200045358,"load_avg_1min":1.9,"runnable_threads":2,"uptime":202624.96822047234},"values":[0.006760130499969819,0.006786347938032122,0.0068690990628965665,0.006621057311349432,0.0065757058746385155,0.006553384186190669,0.006611698188862647,0.006726662686560303,0.006623719313211041,0.006554338624482625],"warmups":[[16,0.006737200812494848]]},{"metadata":{"command_max_rss":16642048,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:44:32.427175","duration":1.404753659007838,"load_avg_1min":1.9,"runnable_threads":1,"uptime":202626.42866110802},"values":[0.006638018376179389,0.006681097436739947,0.006563557375557139,0.006588814749193261,0.00678609643910022,0.006689422561976244,0.006559906687471084,0.006679436562990304,0.006667263000053936,0.00658971562552324],"warmups":[[16,0.00685932650048926]]},{"metadata":{"command_max_rss":16539648,"cpu_freq":"0=5081 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:44:33.883198","duration":1.400742388999788,"load_avg_1min":1.83,"runnable_threads":2,"uptime":202627.8848464489},"values":[0.0066441241888242075,0.006532620123834931,0.006554521562065929,0.006880454375277623,0.006541449061842286,0.006581883499165997,0.006541576436575269,0.006699387062326423,0.006801438688853523,0.006733135687682079],"warmups":[[16,0.006559663750522304]]},{"metadata":{"command_max_rss":16531456,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=59 C, coretemp:Core 0=59 C","date":"2026-04-17 14:44:35.351956","duration":1.409913750976557,"load_avg_1min":1.83,"runnable_threads":1,"uptime":202629.35342931747},"values":[0.006682314437057357,0.0067108269377058605,0.006710986186590162,0.006676484936178895,0.006671798313618638,0.0065827756880025845,0.0067091148121107835,0.00686734131159028,0.006544311938341707,0.006626779500948032],"warmups":[[16,0.006918473312907736]]},{"metadata":{"command_max_rss":16617472,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:44:36.804818","duration":1.3970053610100877,"load_avg_1min":1.83,"runnable_threads":2,"uptime":202630.8064072132},"values":[0.00676880431274185,0.006630252188188024,0.0066166831256850855,0.006597305249670171,0.006673393125311122,0.0066293078125454485,0.006559416562595288,0.0065255030003754655,0.006617663188080769,0.00673482075035281],"warmups":[[16,0.006568323562532896]]},{"metadata":{"command_max_rss":16592896,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=65 C, coretemp:Core 0=60 C","date":"2026-04-17 14:44:38.278395","duration":1.417984144994989,"load_avg_1min":1.84,"runnable_threads":2,"uptime":202632.27992630005},"values":[0.006918069937455584,0.006564762499692733,0.0065979638129647356,0.006680002874418278,0.006715945562973502,0.006647311374763376,0.006721196625221637,0.0068583311258407775,0.007073475937431795,0.0066708331232803175],"warmups":[[16,0.006722144000377739]]},{"metadata":{"command_max_rss":16584704,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:44:39.736069","duration":1.401663512981031,"load_avg_1min":1.84,"runnable_threads":1,"uptime":202633.73761367798},"values":[0.006566014373674989,0.0066245491871086415,0.006705257874273229,0.0067987045003974345,0.006890388813189929,0.006533740313898306,0.006660626375378342,0.006615226311623701,0.0066025883752445225,0.006597565625270363],"warmups":[[16,0.006679362249997212]]},{"metadata":{"command_max_rss":16625664,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:44:41.199165","duration":1.4054734009841923,"load_avg_1min":1.84,"runnable_threads":2,"uptime":202635.2007021904},"values":[0.006692850500257919,0.006732665937306592,0.006618520063057076,0.006594058124392177,0.006539823061757488,0.00673371631091868,0.0066191575624543475,0.0066978719987673685,0.00679027531259635,0.006696497250231914],"warmups":[[16,0.006603654124774039]]},{"metadata":{"command_max_rss":16560128,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=61 C, coretemp:Core 0=60 C","date":"2026-04-17 14:44:42.654740","duration":1.3994064809812699,"load_avg_1min":1.86,"runnable_threads":2,"uptime":202636.65636706352},"values":[0.006543626375787426,0.006585489625649643,0.00669226331228856,0.006719662873365451,0.006687264498395962,0.006821927874625544,0.006606562938031857,0.006568509312273818,0.006518086875075824,0.006797867625209619],"warmups":[[16,0.006608379560930189]]}]},{"metadata":{"command":"/home/mjbommar/src/cpython/venv/cpython3.15-f4470862ed70-compat-31b33d68c68a/bin/python -S -c pass","description":"Performance of the Python startup","loops":32,"name":"python_startup_no_site","tags":["startup"]},"runs":[{"metadata":{"calibrate_loops":32,"command_max_rss":16642048,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:44:44.736030","duration":1.9654382500157226,"load_avg_1min":1.86,"runnable_threads":1,"uptime":202638.7375805378},"warmups":[[1,0.004706184001406655],[2,0.004345788503997028],[4,0.00410602024930995],[8,0.00458584262378281],[16,0.004275892437362927],[32,0.004290740781470959],[32,0.004262119125087338],[32,0.004168295249655785],[32,0.004204180312626704],[32,0.004223615312184847],[32,0.004290751780899882],[32,0.0044148590313852765],[32,0.0042248516247127554],[32,0.004178083843726199],[32,0.004179348937213945],[32,0.004231028467984288]]},{"metadata":{"command_max_rss":16609280,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=66 C","date":"2026-04-17 14:44:46.518279","duration":1.7250667259795591,"load_avg_1min":1.86,"runnable_threads":1,"uptime":202640.5198585987},"values":[0.00428690650005592,0.004216187312522379,0.004232496125041507,0.004164717468484014,0.004263249406903924,0.004309977030970913,0.004209184468891181,0.004205318749882281,0.004229454781125241,0.0041716419382282766],"warmups":[[32,0.0042644036875572056]]},{"metadata":{"command_max_rss":16613376,"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=62 C, coretemp:Core 0=62 C","date":"2026-04-17 14:44:48.300338","duration":1.7259843859937973,"load_avg_1min":1.87,"runnable_threads":2,"uptime":202642.30188894272},"values":[0.004266543374797038,0.004224817812428228,0.0043164532817172585,0.004201305125207,0.004207220812531887,0.004202066531433957,0.004271828281162016,0.004182458374998532,0.004323315000874572,0.004190318561995809],"warmups":[[32,0.0042236165318172425]]},{"metadata":{"command_max_rss":16617472,"cpu_freq":"0=4984 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:44:50.083512","duration":1.7258542760100681,"load_avg_1min":1.87,"runnable_threads":4,"uptime":202644.08494734764},"values":[0.004217486000015924,0.004309727375584771,0.004366593874692626,0.0043911325628869236,0.004161139218922472,0.004122493219256285,0.0041076008119489416,0.004190485281469591,0.0041831104063021485,0.004326478750044771],"warmups":[[32,0.004166662999523396]]},{"metadata":{"command_max_rss":16650240,"cpu_freq":"0=5083 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:44:51.841302","duration":1.6993878910143394,"load_avg_1min":1.87,"runnable_threads":1,"uptime":202645.84288549423},"values":[0.00410882562482584,0.0041095261249211035,0.004238438562424562,0.004206484812129929,0.004188409593552933,0.004156415687248227,0.004144765437558817,0.004128716281229572,0.004149370124650886,0.004186719594144961],"warmups":[[32,0.0042081882183993]]},{"metadata":{"command_max_rss":16625664,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:44:53.596624","duration":1.6981268620002083,"load_avg_1min":1.8,"runnable_threads":1,"uptime":202647.59816598892},"values":[0.004183690062745882,0.004162594594163238,0.004111628874852613,0.004147199219005415,0.004127156312279112,0.004202005906336126,0.0042956879688063054,0.004139122093874903,0.004104176749933686,0.004101221750715922],"warmups":[[32,0.0042367975001980085]]},{"metadata":{"command_max_rss":16646144,"cpu_freq":"0=5083 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:44:55.356899","duration":1.7036681010213215,"load_avg_1min":1.8,"runnable_threads":1,"uptime":202649.35841035843},"values":[0.004195538124804443,0.0042872594685832155,0.004189026625681436,0.004123966187762562,0.004095561406757042,0.00420607356227265,0.004145854936723481,0.004188368500763318,0.00427048603160074,0.004119024374631408],"warmups":[[32,0.00420158025008277]]},{"metadata":{"command_max_rss":16584704,"cpu_freq":"0=4982 MHz","cpu_temp":"coretemp:Package id 0=59 C, coretemp:Core 0=59 C","date":"2026-04-17 14:44:57.120539","duration":1.7078258900146466,"load_avg_1min":1.8,"runnable_threads":2,"uptime":202651.12210059166},"values":[0.004169757468844182,0.00420052837489493,0.00416538596891769,0.004259945156263711,0.004183234499578248,0.004152310437348206,0.004140530281802057,0.004167406187661982,0.004190275312794256,0.004402472874971863],"warmups":[[32,0.004105224812519737]]},{"metadata":{"command_max_rss":16535552,"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:44:58.882452","duration":1.7042835780011956,"load_avg_1min":1.81,"runnable_threads":2,"uptime":202652.88405156136},"values":[0.004127422468627628,0.004140186249969702,0.004189099312498001,0.004195590562630969,0.004285637342945847,0.004208168437799031,0.00414699875000224,0.004134289749345044,0.004222439905788633,0.0041797393751039635],"warmups":[[32,0.004188676687590487]]},{"metadata":{"command_max_rss":16642048,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:45:00.651785","duration":1.7121165620046668,"load_avg_1min":1.81,"runnable_threads":2,"uptime":202654.65330457687},"values":[0.004288232094040723,0.004141587250160228,0.004114034687518142,0.004229823374771513,0.004242055624672503,0.004238504375280172,0.004323081625443592,0.004161746374848008,0.004108648125111358,0.0041314611244160915],"warmups":[[32,0.004288904093300516]]},{"metadata":{"command_max_rss":16629760,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:02.413747","duration":1.7047636790084653,"load_avg_1min":1.81,"runnable_threads":2,"uptime":202656.4152674675},"values":[0.004260953250195598,0.00428950387504301,0.004103998968275846,0.004106652843802294,0.00413341724924976,0.00417470006232179,0.004147370999817213,0.004278313437680481,0.0042061779686264344,0.004138037312259257],"warmups":[[32,0.004167300719018385]]},{"metadata":{"command_max_rss":16613376,"cpu_freq":"0=4973 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:04.168496","duration":1.6990346000238787,"load_avg_1min":1.83,"runnable_threads":6,"uptime":202658.17014598846},"values":[0.004133931936848967,0.004191291781353357,0.004210403406432306,0.004151218312472338,0.004153767687057552,0.004095331250027812,0.004153238624894584,0.004159071405410941,0.004145816906202526,0.004336374218837591],"warmups":[[32,0.004126790406189684]]},{"metadata":{"command_max_rss":16605184,"cpu_freq":"0=4966 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:05.917052","duration":1.6921875659900252,"load_avg_1min":1.83,"runnable_threads":2,"uptime":202659.91869044304},"values":[0.004167234718806867,0.004133063500376011,0.004149216249970777,0.004155116936999548,0.004235907562360808,0.004115396655834047,0.0041032487506527104,0.004102132562366023,0.004141347156291886,0.004167484624304052],"warmups":[[32,0.004249247781444865]]},{"metadata":{"command_max_rss":16621568,"cpu_freq":"0=5088 MHz","cpu_temp":"coretemp:Package id 0=56 C, coretemp:Core 0=56 C","date":"2026-04-17 14:45:07.717806","duration":1.742420069000218,"load_avg_1min":1.84,"runnable_threads":1,"uptime":202661.71936655045},"values":[0.0041363112186445505,0.004585614906318369,0.004097690592971048,0.00416592559304263,0.004181713094112638,0.004189501968539844,0.005076917780570511,0.004170754186816339,0.004134611343033612,0.0041652292502476485],"warmups":[[32,0.004278937843082531]]},{"metadata":{"command_max_rss":16654336,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:45:09.489021","duration":1.714327648980543,"load_avg_1min":1.84,"runnable_threads":1,"uptime":202663.49054455757},"values":[0.004218266624775424,0.004211493249385967,0.004142057656281395,0.004134675406021415,0.0042062681868628715,0.004163076750046457,0.004193181937807822,0.004348332906374708,0.004238834124407731,0.0041723609383552684],"warmups":[[32,0.004218160124764836]]},{"metadata":{"command_max_rss":16654336,"cpu_freq":"0=5083 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:45:11.259021","duration":1.7139784620085265,"load_avg_1min":1.84,"runnable_threads":3,"uptime":202665.26055812836},"values":[0.004218943593514268,0.004197733999717457,0.004319385187955049,0.0041461079999862704,0.0041362737811141415,0.004143019625189481,0.004178568749921396,0.004210896125186991,0.004289835187591962,0.004230240374454297],"warmups":[[32,0.004243051562298206]]},{"metadata":{"command_max_rss":16621568,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=60 C, coretemp:Core 0=60 C","date":"2026-04-17 14:45:13.024220","duration":1.7087436669971794,"load_avg_1min":1.86,"runnable_threads":1,"uptime":202667.02575445175},"values":[0.004180761343377526,0.0041788147818806465,0.004192506687104469,0.004175722280706395,0.004216218500005198,0.004231901687489881,0.00418041921875556,0.004186065500107361,0.004215676874991914,0.004165873750025639],"warmups":[[32,0.004172954030764231]]},{"metadata":{"command_max_rss":16629760,"cpu_freq":"0=5082 MHz","cpu_temp":"coretemp:Package id 0=62 C, coretemp:Core 0=62 C","date":"2026-04-17 14:45:14.786960","duration":1.7063212590001058,"load_avg_1min":1.86,"runnable_threads":2,"uptime":202668.7884809971},"values":[0.0041257967186538735,0.004122269530853373,0.004198002406155865,0.004220764312776737,0.0041277195314251,0.004272057843991206,0.00415590418742795,0.00420572243820061,0.004223628625368292,0.004206578656521742],"warmups":[[32,0.004171015624706342]]},{"metadata":{"command_max_rss":16564224,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:16.546215","duration":1.7017633119830862,"load_avg_1min":1.86,"runnable_threads":1,"uptime":202670.54775762558},"values":[0.004294942344131414,0.004199832562335359,0.004132138593377022,0.004112987312510086,0.004148021781475109,0.004195767155579233,0.004223455187457148,0.004212570156596485,0.004118349655982456,0.004114294156352116],"warmups":[[32,0.004182465969279292]]},{"metadata":{"command_max_rss":16580608,"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:18.303305","duration":1.701496950990986,"load_avg_1min":1.87,"runnable_threads":1,"uptime":202672.30481863022},"values":[0.004127602468543046,0.0041514563436066965,0.004324662312683358,0.004224861375405453,0.004118040593311889,0.004158186843596923,0.00416960275015299,0.004153259250415431,0.004256796749359637,0.004126815280869778],"warmups":[[32,0.004153286062319239]]},{"metadata":{"command_max_rss":16609280,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:20.057423","duration":1.6985860410204623,"load_avg_1min":1.87,"runnable_threads":1,"uptime":202674.0589413643},"values":[0.004140949406973959,0.0041811242190306075,0.00417276628104446,0.0042327917499278556,0.004165540188296291,0.004169714187810314,0.00416165178103256,0.004151465500399354,0.004161103936894506,0.004161526937423332],"warmups":[[32,0.004103969844436506]]}]},{"metadata":{"description":"Microbenchmark for Python's sequence unpacking.","inner_loops":400,"loops":16384,"name":"unpack_sequence","python_cflags":"-fno-strict-overflow -Wsign-compare -DNDEBUG -g -O3 -Wall","python_compiler":"GCC 15.2.0","python_config_args":"'--prefix=/tmp/cpython-build'","python_executable":"/home/mjbommar/src/cpython/venv/cpython3.15-f4470862ed70-compat-31b33d68c68a/bin/python","python_implementation":"cpython","python_version":"3.15.0a8+ (64-bit) revision c5e6bb4335b","tags":[],"timer":"clock_gettime(CLOCK_MONOTONIC), resolution: 1.00 ns"},"runs":[{"metadata":{"calibrate_loops":16384,"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:20.849769","duration":0.6774532489944249,"load_avg_1min":1.87,"mem_max_rss":25690112,"runnable_threads":1,"uptime":202674.85160398483},"warmups":[[1,5.241752660367638e-08],[2,4.9771224439609797e-08],[4,4.949186404701322e-08],[8,4.8920928747975265e-08],[16,4.8455153773829804e-08],[32,6.619539135499508e-08],[64,2.8747072065016256e-08],[128,4.1765409832805744e-08],[256,3.0335712608575705e-08],[512,2.5538310524098052e-08],[1024,2.2481633337179118e-08],[2048,2.1072228975071994e-08],[4096,2.0658890971247958e-08],[8192,2.044679870749633e-08],[16384,2.0005075223039624e-08],[16384,2.013956359903091e-08],[16384,2.0257334290008088e-08],[16384,1.997711975398886e-08]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:21.448961","duration":0.5376828849839512,"load_avg_1min":1.87,"mem_max_rss":25706496,"runnable_threads":1,"uptime":202675.45079112053},"values":[2.0154578397324486e-08,2.0137035829925765e-08,2.0030818022043206e-08],"warmups":[[16384,2.0128575135558436e-08]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:22.046004","duration":0.5375271750090178,"load_avg_1min":1.87,"mem_max_rss":25690112,"runnable_threads":1,"uptime":202676.04785466194},"values":[2.0079793396909907e-08,2.0110145722007644e-08,2.0245881797720244e-08],"warmups":[[16384,2.0018684532274734e-08]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:22.644285","duration":0.5354340129997581,"load_avg_1min":1.88,"mem_max_rss":25690112,"runnable_threads":1,"uptime":202676.6461455822},"values":[2.0054402773972413e-08,1.9936214141758057e-08,2.00595562738215e-08],"warmups":[[16384,2.007133423020946e-08]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:23.247160","duration":0.5397062489937525,"load_avg_1min":1.88,"mem_max_rss":25690112,"runnable_threads":1,"uptime":202677.24898409843},"values":[2.013000335754356e-08,2.0258059536537586e-08,2.0274961087807242e-08],"warmups":[[16384,2.0120011292590334e-08]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:23.845059","duration":0.5374144870147575,"load_avg_1min":1.88,"mem_max_rss":25690112,"runnable_threads":2,"uptime":202677.84697556496},"values":[2.004052413795421e-08,2.016482864242164e-08,2.0085337220088206e-08],"warmups":[[16384,2.005899551793533e-08]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:45:24.450588","duration":0.5431800619990099,"load_avg_1min":1.88,"mem_max_rss":25690112,"runnable_threads":1,"uptime":202678.45237731934},"values":[2.0068840331788352e-08,2.0709709169786095e-08,2.0496567683103705e-08],"warmups":[[16384,2.003704604902623e-08]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:45:25.054444","duration":0.5427542850084137,"load_avg_1min":1.88,"mem_max_rss":25690112,"runnable_threads":2,"uptime":202679.05627155304},"values":[2.0373655700289816e-08,2.0351504215199156e-08,2.0275487977450267e-08],"warmups":[[16384,2.0254415131759628e-08]]},{"metadata":{"cpu_freq":"0=5009 MHz","cpu_temp":"coretemp:Package id 0=75 C, coretemp:Core 0=73 C","date":"2026-04-17 14:45:25.656882","duration":0.541162703972077,"load_avg_1min":1.88,"mem_max_rss":25718784,"runnable_threads":2,"uptime":202679.65869283676},"values":[2.0233138124936543e-08,2.0236128541739616e-08,2.0220667420467465e-08],"warmups":[[16384,2.0264488065357968e-08]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=75 C, coretemp:Core 0=73 C","date":"2026-04-17 14:45:26.252535","duration":0.5350232310011052,"load_avg_1min":1.88,"mem_max_rss":25690112,"runnable_threads":1,"uptime":202680.25434422493},"values":[1.996386001845707e-08,2.0004849550225857e-08,2.0159706424216496e-08],"warmups":[[16384,1.9950304870341995e-08]]},{"metadata":{"cpu_freq":"0=5001 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:26.868075","duration":0.556582701014122,"load_avg_1min":1.88,"mem_max_rss":25690112,"runnable_threads":2,"uptime":202680.86989617348},"values":[2.0872215116263248e-08,2.0988170930102968e-08,2.0800210571714217e-08],"warmups":[[16384,2.066849731363618e-08]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:27.466090","duration":0.537682999012759,"load_avg_1min":1.88,"mem_max_rss":25690112,"runnable_threads":2,"uptime":202681.46790337563},"values":[2.0188426668177327e-08,2.0167169192397693e-08,2.0100506437081832e-08],"warmups":[[16384,2.0034329071272338e-08]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:28.093368","duration":0.565123947977554,"load_avg_1min":2.53,"mem_max_rss":25690112,"runnable_threads":5,"uptime":202682.09520578384},"values":[2.1267335963415233e-08,2.1103950347267642e-08,2.0862942808896888e-08],"warmups":[[16384,2.13551264938161e-08]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:28.697567","duration":0.541905685007805,"load_avg_1min":2.53,"mem_max_rss":25690112,"runnable_threads":2,"uptime":202682.69940328598},"values":[2.0151156614467425e-08,2.049758819566705e-08,2.0311044770515706e-08],"warmups":[[16384,2.0124623869577363e-08]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:29.297899","duration":0.5410410230106208,"load_avg_1min":2.53,"mem_max_rss":25714688,"runnable_threads":1,"uptime":202683.2997226715},"values":[2.0184152527136234e-08,2.026252716280652e-08,2.02594406095713e-08],"warmups":[[16384,2.0279729766592425e-08]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:29.906709","duration":0.546999065001728,"load_avg_1min":2.53,"mem_max_rss":25690112,"runnable_threads":2,"uptime":202683.90852046013},"values":[2.0594526826123173e-08,2.0415487975711245e-08,2.0649965510877167e-08],"warmups":[[16384,2.0211540072700985e-08]]},{"metadata":{"cpu_freq":"0=4984 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:30.524435","duration":0.557767029007664,"load_avg_1min":2.53,"mem_max_rss":25690112,"runnable_threads":2,"uptime":202684.5262618065},"values":[2.0905493927081408e-08,2.095012954672626e-08,2.0817568056052947e-08],"warmups":[[16384,2.087030212205576e-08]]},{"metadata":{"cpu_freq":"0=5070 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:31.130379","duration":0.546852127998136,"load_avg_1min":2.53,"mem_max_rss":25718784,"runnable_threads":2,"uptime":202685.13196253777},"values":[2.0586081390661094e-08,2.0455030513844007e-08,2.0401949467618862e-08],"warmups":[[16384,2.04998901365272e-08]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:31.729971","duration":0.5399820550228469,"load_avg_1min":2.53,"mem_max_rss":25690112,"runnable_threads":3,"uptime":202685.7318637371},"values":[2.0310778960919152e-08,2.0049293518731302e-08,2.0137701874922697e-08],"warmups":[[16384,2.025509567182837e-08]]},{"metadata":{"cpu_freq":"0=5084 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:32.338791","duration":0.5466530749981757,"load_avg_1min":2.53,"mem_max_rss":25788416,"runnable_threads":1,"uptime":202686.34062170982},"values":[2.027995437359209e-08,2.0653732302200466e-08,2.0409021757039625e-08],"warmups":[[16384,2.0494013361904705e-08]]},{"metadata":{"cpu_freq":"0=4983 MHz","cpu_temp":"coretemp:Package id 0=62 C, coretemp:Core 0=62 C","date":"2026-04-17 14:45:32.941831","duration":0.541529948997777,"load_avg_1min":2.49,"mem_max_rss":25690112,"runnable_threads":1,"uptime":202686.94367408752},"values":[2.0041107480217592e-08,2.028873626880312e-08,2.040496780431056e-08],"warmups":[[16384,2.029371734657559e-08]]}]},{"metadata":{"description":"Test the performance of pickling.","inner_loops":20,"loops":1024,"name":"unpickle","pickle_module":"pickle","pickle_protocol":"5","python_cflags":"-fno-strict-overflow -Wsign-compare -DNDEBUG -g -O3 -Wall","python_compiler":"GCC 15.2.0","python_config_args":"'--prefix=/tmp/cpython-build'","python_executable":"/home/mjbommar/src/cpython/venv/cpython3.15-f4470862ed70-compat-31b33d68c68a/bin/python","python_implementation":"cpython","python_version":"3.15.0a8+ (64-bit) revision c5e6bb4335b","tags":["serialize"],"timer":"clock_gettime(CLOCK_MONOTONIC), resolution: 1.00 ns"},"runs":[{"metadata":{"calibrate_loops":1024,"cpu_freq":"0=5081 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:33.948958","duration":0.8876476199948229,"load_avg_1min":2.49,"mem_max_rss":24752128,"runnable_threads":1,"uptime":202687.9508845806},"warmups":[[1,1.0348050273023545e-05],[2,8.777849870966747e-06],[4,8.630449883639812e-06],[8,8.496687405568082e-06],[16,8.575862466386752e-06],[32,8.444157811027252e-06],[64,8.622966402072051e-06],[128,8.582912107613083e-06],[256,8.566041992708051e-06],[512,8.635773826881633e-06],[1024,8.50667255889448e-06],[1024,8.551313231919267e-06],[1024,8.62466406204021e-06],[1024,8.527041504180489e-06]]},{"metadata":{"cpu_freq":"0=4925 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:34.726355","duration":0.7161251509969588,"load_avg_1min":2.49,"mem_max_rss":24834048,"runnable_threads":5,"uptime":202688.72819280624},"values":[8.60907739195227e-06,8.571440477567194e-06,8.69986933622613e-06],"warmups":[[1024,8.574957274731786e-06]]},{"metadata":{"cpu_freq":"0=5083 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:35.513896","duration":0.7277632960176561,"load_avg_1min":2.49,"mem_max_rss":24834048,"runnable_threads":1,"uptime":202689.5156941414},"values":[8.808501854673523e-06,8.823694629711554e-06,8.654118506967733e-06],"warmups":[[1024,8.746610303944635e-06]]},{"metadata":{"cpu_freq":"0=5083 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:36.292319","duration":0.718780647002859,"load_avg_1min":2.49,"mem_max_rss":24834048,"runnable_threads":1,"uptime":202690.29412817955},"values":[8.592341502833279e-06,8.650922022468422e-06,8.668662060529186e-06],"warmups":[[1024,8.679670703770625e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:37.099706","duration":0.7483995519869495,"load_avg_1min":2.49,"mem_max_rss":24834048,"runnable_threads":2,"uptime":202691.10152888298},"values":[8.991627686327774e-06,9.13537309656931e-06,8.907148584569314e-06],"warmups":[[1024,8.992872217561398e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:37.887668","duration":0.7262782480102032,"load_avg_1min":2.45,"mem_max_rss":24834048,"runnable_threads":1,"uptime":202691.8894762993},"values":[8.763781737286536e-06,8.641731250236262e-06,8.75511562412612e-06],"warmups":[[1024,8.793359033631986e-06]]},{"metadata":{"cpu_freq":"0=5089 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:38.656553","duration":0.709169039997505,"load_avg_1min":2.45,"mem_max_rss":24834048,"runnable_threads":2,"uptime":202692.65840673447},"values":[8.516832079408231e-06,8.521013184292769e-06,8.473121093288683e-06],"warmups":[[1024,8.564970360680491e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:39.439343","duration":0.7215038220165297,"load_avg_1min":2.45,"mem_max_rss":24834048,"runnable_threads":3,"uptime":202693.44121742249},"values":[8.614555956398817e-06,8.66238164007882e-06,8.68876777389005e-06],"warmups":[[1024,8.736371778184094e-06]]},{"metadata":{"cpu_freq":"0=5058 MHz","cpu_temp":"coretemp:Package id 0=75 C, coretemp:Core 0=75 C","date":"2026-04-17 14:45:40.215698","duration":0.7158383050118573,"load_avg_1min":2.45,"mem_max_rss":24834048,"runnable_threads":1,"uptime":202694.21747255325},"values":[8.601600976021473e-06,8.588804101350434e-06,8.554200341848173e-06],"warmups":[[1024,8.712931004595248e-06]]},{"metadata":{"cpu_freq":"0=4982 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:40.976823","duration":0.7035772009985521,"load_avg_1min":2.45,"mem_max_rss":24834048,"runnable_threads":3,"uptime":202694.97871303558},"values":[8.39633115106153e-06,8.542708789605058e-06,8.433210595626406e-06],"warmups":[[1024,8.460129980392139e-06]]},{"metadata":{"cpu_freq":"0=4985 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:41.751529","duration":0.7146784120122902,"load_avg_1min":2.45,"mem_max_rss":24834048,"runnable_threads":1,"uptime":202695.75339317322},"values":[8.623095457949147e-06,8.559505126015665e-06,8.600692724769488e-06],"warmups":[[1024,8.594572119591248e-06]]},{"metadata":{"cpu_freq":"0=5083 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:42.525636","duration":0.7153891189955175,"load_avg_1min":2.45,"mem_max_rss":24834048,"runnable_threads":1,"uptime":202696.5273900032},"values":[8.58510722707706e-06,8.600658155444307e-06,8.603787060224022e-06],"warmups":[[1024,8.635197313822119e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:43.285599","duration":0.7011471099976916,"load_avg_1min":2.33,"mem_max_rss":24834048,"runnable_threads":3,"uptime":202697.28739595413},"values":[8.46492661139564e-06,8.392226953901627e-06,8.399163036187929e-06],"warmups":[[1024,8.47972856377055e-06]]},{"metadata":{"cpu_freq":"0=4947 MHz","cpu_temp":"coretemp:Package id 0=73 C, coretemp:Core 0=73 C","date":"2026-04-17 14:45:44.070244","duration":0.7242017739918083,"load_avg_1min":2.33,"mem_max_rss":24834048,"runnable_threads":3,"uptime":202698.07230949402},"values":[8.688551562840986e-06,8.789310936663241e-06,8.66365244149847e-06],"warmups":[[1024,8.700438671382927e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:44.854725","duration":0.7246943369973451,"load_avg_1min":2.33,"mem_max_rss":24834048,"runnable_threads":1,"uptime":202698.85653042793},"values":[8.79737846730677e-06,8.648698242552655e-06,8.691341406574793e-06],"warmups":[[1024,8.747938915121268e-06]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:45.613777","duration":0.7014663190057036,"load_avg_1min":2.33,"mem_max_rss":24834048,"runnable_threads":2,"uptime":202699.61564159393},"values":[8.403684618940588e-06,8.471215919314545e-06,8.491850438474558e-06],"warmups":[[1024,8.38363764614769e-06]]},{"metadata":{"cpu_freq":"0=4918 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:46.375813","duration":0.7044202699908055,"load_avg_1min":2.33,"mem_max_rss":24834048,"runnable_threads":2,"uptime":202700.37775564194},"values":[8.489038525283376e-06,8.411435743482798e-06,8.464053222212442e-06],"warmups":[[1024,8.506085448800604e-06]]},{"metadata":{"cpu_freq":"0=5082 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:47.145741","duration":0.7112486620026175,"load_avg_1min":2.33,"mem_max_rss":24834048,"runnable_threads":3,"uptime":202701.14743185043},"values":[8.53857661127222e-06,8.587462744458207e-06,8.55235327179571e-06],"warmups":[[1024,8.54824360345674e-06]]},{"metadata":{"cpu_freq":"0=5094 MHz","cpu_temp":"coretemp:Package id 0=74 C, coretemp:Core 0=74 C","date":"2026-04-17 14:45:47.917257","duration":0.711858916998608,"load_avg_1min":2.7,"mem_max_rss":24834048,"runnable_threads":3,"uptime":202701.91908812523},"values":[8.577424853228877e-06,8.599723975066808e-06,8.564213378292606e-06],"warmups":[[1024,8.495619776738295e-06]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=74 C, coretemp:Core 0=74 C","date":"2026-04-17 14:45:48.686573","duration":0.7089379790122621,"load_avg_1min":2.7,"mem_max_rss":24834048,"runnable_threads":2,"uptime":202702.68837809563},"values":[8.562319091254268e-06,8.495962059384966e-06,8.503603125120662e-06],"warmups":[[1024,8.533767480400912e-06]]},{"metadata":{"cpu_freq":"0=4991 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:49.456201","duration":0.710390975989867,"load_avg_1min":2.7,"mem_max_rss":24834048,"runnable_threads":1,"uptime":202703.45800495148},"values":[8.550547265429032e-06,8.529045409488845e-06,8.4941395016358e-06],"warmups":[[1024,8.599816942478355e-06]]}]},{"metadata":{"description":"Test the performance of pickling.","inner_loops":10,"loops":4096,"name":"unpickle_list","pickle_module":"pickle","pickle_protocol":"5","python_cflags":"-fno-strict-overflow -Wsign-compare -DNDEBUG -g -O3 -Wall","python_compiler":"GCC 15.2.0","python_config_args":"'--prefix=/tmp/cpython-build'","python_executable":"/home/mjbommar/src/cpython/venv/cpython3.15-f4470862ed70-compat-31b33d68c68a/bin/python","python_implementation":"cpython","python_version":"3.15.0a8+ (64-bit) revision c5e6bb4335b","tags":["serialize"],"timer":"clock_gettime(CLOCK_MONOTONIC), resolution: 1.00 ns"},"runs":[{"metadata":{"calibrate_loops":4096,"cpu_freq":"0=5069 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:50.149304","duration":0.5726136879820842,"load_avg_1min":2.7,"mem_max_rss":24788992,"runnable_threads":2,"uptime":202704.1509361267},"warmups":[[1,3.3710995921865107e-06],[2,2.701599441934377e-06],[4,2.656774449860677e-06],[8,2.661150210769847e-06],[16,2.7337062419974243e-06],[32,2.6971937586495186e-06],[64,2.681185924302554e-06],[128,2.6987953106072384e-06],[256,2.6865046834245733e-06],[512,2.686618165625987e-06],[1024,2.725634669786814e-06],[2048,2.7662465328148755e-06],[4096,2.769760009613265e-06],[4096,2.7352503174427056e-06],[4096,2.733494360285249e-06],[4096,2.741475854861619e-06]]},{"metadata":{"cpu_freq":"0=4926 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:50.661634","duration":0.4501278639945667,"load_avg_1min":2.7,"mem_max_rss":24797184,"runnable_threads":4,"uptime":202704.66346669197},"values":[2.6569903809559038e-06,2.666820556385119e-06,2.704717260826328e-06],"warmups":[[4096,2.6973030763599582e-06]]},{"metadata":{"cpu_freq":"0=5062 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:51.177129","duration":0.45445596298668534,"load_avg_1min":2.7,"mem_max_rss":24698880,"runnable_threads":1,"uptime":202705.17875385284},"values":[2.756932421732472e-06,2.6821716552660748e-06,2.7114804204586564e-06],"warmups":[[4096,2.7002362060102316e-06]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=62 C, coretemp:Core 0=62 C","date":"2026-04-17 14:45:51.691587","duration":0.4550651469908189,"load_avg_1min":2.7,"mem_max_rss":24678400,"runnable_threads":2,"uptime":202705.69340848923},"values":[2.7067421875415222e-06,2.7090135255036785e-06,2.723170800322805e-06],"warmups":[[4096,2.713487621974764e-06]]},{"metadata":{"cpu_freq":"0=4981 MHz","cpu_temp":"coretemp:Package id 0=62 C, coretemp:Core 0=62 C","date":"2026-04-17 14:45:52.203434","duration":0.4520685549941845,"load_avg_1min":2.7,"mem_max_rss":24801280,"runnable_threads":2,"uptime":202706.20509552956},"values":[2.6844969973183195e-06,2.6888051756657207e-06,2.7184849365369247e-06],"warmups":[[4096,2.699419872698172e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:52.708855","duration":0.445831389981322,"load_avg_1min":2.73,"mem_max_rss":24854528,"runnable_threads":1,"uptime":202706.71061635017},"values":[2.6331530030176966e-06,2.6700370362675586e-06,2.659467040899699e-06],"warmups":[[4096,2.671070239301798e-06]]},{"metadata":{"cpu_freq":"0=5085 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:53.223939","duration":0.4565227180137299,"load_avg_1min":2.73,"mem_max_rss":24743936,"runnable_threads":1,"uptime":202707.22572398186},"values":[2.696676879310189e-06,2.711574828850871e-06,2.7226068112895517e-06],"warmups":[[4096,2.764086841011704e-06]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:53.734366","duration":0.4516094620048534,"load_avg_1min":2.73,"mem_max_rss":24662016,"runnable_threads":3,"uptime":202707.73624634743},"values":[2.671788476504844e-06,2.6768736333337984e-06,2.71532993210144e-06],"warmups":[[4096,2.6889156742981866e-06]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:54.251155","duration":0.45655884500592947,"load_avg_1min":2.73,"mem_max_rss":24829952,"runnable_threads":1,"uptime":202708.25290846825},"values":[2.713916259722282e-06,2.709931738564819e-06,2.7118140870641128e-06],"warmups":[[4096,2.7589822757079217e-06]]},{"metadata":{"cpu_freq":"0=5046 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:54.761626","duration":0.4523886209935881,"load_avg_1min":2.73,"mem_max_rss":24698880,"runnable_threads":2,"uptime":202708.76341819763},"values":[2.6878556148801636e-06,2.709293652003453e-06,2.722710522817806e-06],"warmups":[[4096,2.6788609623906723e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:55.266329","duration":0.445310237002559,"load_avg_1min":2.73,"mem_max_rss":24748032,"runnable_threads":1,"uptime":202709.2679541111},"values":[2.645383300858839e-06,2.6576937017352973e-06,2.656314404703153e-06],"warmups":[[4096,2.67005529792641e-06]]},{"metadata":{"cpu_freq":"0=4983 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:55.774035","duration":0.4508822500065435,"load_avg_1min":2.73,"mem_max_rss":24711168,"runnable_threads":2,"uptime":202709.7758078575},"values":[2.6760118650770436e-06,2.684952368525728e-06,2.728710327204453e-06],"warmups":[[4096,2.677222753533215e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:56.283281","duration":0.45022606500424445,"load_avg_1min":2.73,"mem_max_rss":24752128,"runnable_threads":1,"uptime":202710.2849497795},"values":[2.67770959467839e-06,2.6968464602816767e-06,2.6841170409852567e-06],"warmups":[[4096,2.6897282715765415e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:56.793201","duration":0.45270123600494117,"load_avg_1min":2.73,"mem_max_rss":24674304,"runnable_threads":1,"uptime":202710.79507565498},"values":[2.7431238770248e-06,2.7109866692853758e-06,2.6745632567326537e-06],"warmups":[[4096,2.6721969234699826e-06]]},{"metadata":{"cpu_freq":"0=5081 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:57.303958","duration":0.4526784740155563,"load_avg_1min":2.73,"mem_max_rss":24662016,"runnable_threads":2,"uptime":202711.3055846691},"values":[2.715551098475544e-06,2.7101557130038147e-06,2.6998453854787385e-06],"warmups":[[4096,2.6872337159034033e-06]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:57.810831","duration":0.4497252209985163,"load_avg_1min":2.67,"mem_max_rss":24702976,"runnable_threads":2,"uptime":202711.81270432472},"values":[2.6782682375880993e-06,2.70516789555586e-06,2.6865900878192405e-06],"warmups":[[4096,2.659500292878647e-06]]},{"metadata":{"cpu_freq":"0=5075 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:45:58.315438","duration":0.44567873497726396,"load_avg_1min":2.67,"mem_max_rss":24694784,"runnable_threads":2,"uptime":202712.3172931671},"values":[2.651973291278864e-06,2.6694456543907562e-06,2.661821361726879e-06],"warmups":[[4096,2.6498087891013712e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:58.813191","duration":0.440518297982635,"load_avg_1min":2.67,"mem_max_rss":24662016,"runnable_threads":1,"uptime":202712.81494760513},"values":[2.633690332487504e-06,2.6385697019293274e-06,2.6341206790903014e-06],"warmups":[[4096,2.6108393548440746e-06]]},{"metadata":{"cpu_freq":"0=5080 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:59.320997","duration":0.4500432009808719,"load_avg_1min":2.67,"mem_max_rss":24883200,"runnable_threads":1,"uptime":202713.32268357277},"values":[2.6853136724014347e-06,2.6767130862026534e-06,2.6950974366002358e-06],"warmups":[[4096,2.689339428485482e-06]]},{"metadata":{"cpu_freq":"0=5081 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:45:59.831308","duration":0.45352976699359715,"load_avg_1min":2.67,"mem_max_rss":24731648,"runnable_threads":1,"uptime":202713.83304214478},"values":[2.676956396641117e-06,2.7249839845922e-06,2.7411913329444816e-06],"warmups":[[4096,2.6822877437382432e-06]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=63 C, coretemp:Core 0=63 C","date":"2026-04-17 14:46:00.340526","duration":0.44877571999677457,"load_avg_1min":2.67,"mem_max_rss":24662016,"runnable_threads":1,"uptime":202714.3422718048},"values":[2.665290575976087e-06,2.670545386251888e-06,2.6777177495773687e-06],"warmups":[[4096,2.6969096921902745e-06]]}]},{"metadata":{"description":"Test the performance of pickling.","inner_loops":20,"loops":64,"name":"unpickle_pure_python","pickle_module":"pickle","pickle_protocol":"5","python_cflags":"-fno-strict-overflow -Wsign-compare -DNDEBUG -g -O3 -Wall","python_compiler":"GCC 15.2.0","python_config_args":"'--prefix=/tmp/cpython-build'","python_executable":"/home/mjbommar/src/cpython/venv/cpython3.15-f4470862ed70-compat-31b33d68c68a/bin/python","python_implementation":"cpython","python_version":"3.15.0a8+ (64-bit) revision c5e6bb4335b","tags":["serialize"],"timer":"clock_gettime(CLOCK_MONOTONIC), resolution: 1.00 ns"},"runs":[{"metadata":{"calibrate_loops":64,"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:46:01.244956","duration":0.7870821010146756,"load_avg_1min":2.67,"mem_max_rss":24649728,"runnable_threads":1,"uptime":202715.2467057705},"warmups":[[1,0.00012475729890866206],[2,0.00012084720001439563],[4,0.00012105288769816979],[8,0.00011991838127869414],[16,0.00012023225308439578],[32,0.00012217737034916353],[64,0.00012225755624513114],[64,0.00012232461951953156],[64,0.00012046855547396263],[64,0.0001205512523483776]]},{"metadata":{"cpu_freq":"0=4949 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:46:01.941558","duration":0.636473594000563,"load_avg_1min":2.67,"mem_max_rss":24838144,"runnable_threads":2,"uptime":202715.94337296486},"values":[0.00012248793516391742,0.000122796561731775,0.0001221599304699339],"warmups":[[64,0.00012107528048090898]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=62 C, coretemp:Core 0=62 C","date":"2026-04-17 14:46:02.628479","duration":0.6288669529894833,"load_avg_1min":2.62,"mem_max_rss":24838144,"runnable_threads":2,"uptime":202716.63039016724},"values":[0.00012038559139000426,0.00012003110859950538,0.0001207343163969199],"warmups":[[64,0.00012134794687881367]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=62 C, coretemp:Core 0=62 C","date":"2026-04-17 14:46:03.316595","duration":0.6278041850018781,"load_avg_1min":2.62,"mem_max_rss":24838144,"runnable_threads":1,"uptime":202717.31828212738},"values":[0.00012068324219853821,0.00012067096406553901,0.00012035430156629446],"warmups":[[64,0.00012037272890665917]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=78 C, coretemp:Core 0=78 C","date":"2026-04-17 14:46:04.000825","duration":0.6274114890256897,"load_avg_1min":2.62,"mem_max_rss":24838144,"runnable_threads":1,"uptime":202718.0025653839},"values":[0.0001208415367273119,0.0001200020640681032,0.00012087326406344801],"warmups":[[64,0.00011987369766757184]]},{"metadata":{"cpu_freq":"0=4970 MHz","cpu_temp":"coretemp:Package id 0=78 C, coretemp:Core 0=78 C","date":"2026-04-17 14:46:04.680756","duration":0.6233598279941361,"load_avg_1min":2.62,"mem_max_rss":24838144,"runnable_threads":2,"uptime":202718.68258047104},"values":[0.00011999252967598295,0.00011918459845219331,0.00011987090470029216],"warmups":[[64,0.00011914704452919977]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:46:05.374672","duration":0.6338679240143392,"load_avg_1min":2.62,"mem_max_rss":24838144,"runnable_threads":2,"uptime":202719.3764410019},"values":[0.00012215611170631746,0.00012125715311412932,0.00012123146327667201],"warmups":[[64,0.00012187259530946904]]},{"metadata":{"cpu_freq":"0=5086 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:46:06.065631","duration":0.6328763949859422,"load_avg_1min":2.62,"mem_max_rss":24838144,"runnable_threads":1,"uptime":202720.0674135685},"values":[0.00012110279531043488,0.0001221859929501079,0.000122875097645192],"warmups":[[64,0.00011958613672504725]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:46:06.752030","duration":0.6284874879929703,"load_avg_1min":2.62,"mem_max_rss":24838144,"runnable_threads":2,"uptime":202720.75380945206},"values":[0.00011931480155453755,0.00012092352967556508,0.0001216276937384464],"warmups":[[64,0.00012037318595048419]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:46:07.461612","duration":0.6501985500217415,"load_avg_1min":2.62,"mem_max_rss":24838144,"runnable_threads":2,"uptime":202721.46333003044},"values":[0.00012035232734888268,0.00013982533437228994,0.00011909303907486901],"warmups":[[64,0.00012015270781375875]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=74 C, coretemp:Core 0=74 C","date":"2026-04-17 14:46:08.147684","duration":0.6300335649866611,"load_avg_1min":2.49,"mem_max_rss":24838144,"runnable_threads":2,"uptime":202722.1495294571},"values":[0.00012117200469674572,0.00012114115313579532,0.0001210211812349371],"warmups":[[64,0.00012004873201476585]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=74 C, coretemp:Core 0=74 C","date":"2026-04-17 14:46:08.840571","duration":0.6311629870033357,"load_avg_1min":2.49,"mem_max_rss":24838144,"runnable_threads":2,"uptime":202722.84235835075},"values":[0.00011997916094514949,0.00012039325702062342,0.00012188209532268957],"warmups":[[64,0.00012224882345890364]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:46:09.536777","duration":0.6382660089875571,"load_avg_1min":2.49,"mem_max_rss":24838144,"runnable_threads":1,"uptime":202723.5385081768},"values":[0.00012257026173756458,0.0001224121023369662,0.0001221869179744317],"warmups":[[64,0.00012290662343730218]]},{"metadata":{"cpu_freq":"0=5067 MHz","cpu_temp":"coretemp:Package id 0=67 C, coretemp:Core 0=67 C","date":"2026-04-17 14:46:10.230721","duration":0.6365812639996875,"load_avg_1min":2.49,"mem_max_rss":24838144,"runnable_threads":2,"uptime":202724.23237466812},"values":[0.0001226695929744892,0.00012259478360192587,0.00012113147499803745],"warmups":[[64,0.00012238908279869066]]},{"metadata":{"cpu_freq":"0=5002 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:46:10.913963","duration":0.6249564779864158,"load_avg_1min":2.49,"mem_max_rss":24838144,"runnable_threads":3,"uptime":202724.91582345963},"values":[0.00011866920781358203,0.00012159668046933803,0.0001199239320385459],"warmups":[[64,0.00011930918749385455]]},{"metadata":{"cpu_freq":"0=4900 MHz","cpu_temp":"coretemp:Package id 0=64 C, coretemp:Core 0=64 C","date":"2026-04-17 14:46:11.601041","duration":0.6285670979996212,"load_avg_1min":2.49,"mem_max_rss":24838144,"runnable_threads":3,"uptime":202725.60313653946},"values":[0.0001209178718909243,0.000120313635943603,0.00012021356408240536],"warmups":[[64,0.00012023080937524355]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=72 C, coretemp:Core 0=66 C","date":"2026-04-17 14:46:12.293658","duration":0.6302803420112468,"load_avg_1min":2.49,"mem_max_rss":24838144,"runnable_threads":2,"uptime":202726.2954711914},"values":[0.00012122892892421077,0.00012119245311623673,0.00012044052734836442],"warmups":[[64,0.00012053994216785214]]},{"metadata":{"cpu_freq":"0=4983 MHz","cpu_temp":"coretemp:Package id 0=72 C, coretemp:Core 0=66 C","date":"2026-04-17 14:46:12.992803","duration":0.639272536005592,"load_avg_1min":2.45,"mem_max_rss":24838144,"runnable_threads":2,"uptime":202726.99463057518},"values":[0.00012193270233638032,0.00012359716486116669,0.00012313880624788],"warmups":[[64,0.00012189719686830358]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=76 C, coretemp:Core 0=67 C","date":"2026-04-17 14:46:13.684126","duration":0.6329223290085793,"load_avg_1min":2.45,"mem_max_rss":24838144,"runnable_threads":2,"uptime":202727.68589925766},"values":[0.00012148716562023764,0.00012176168670521292,0.00012095343749933818],"warmups":[[64,0.00012143407109306281]]},{"metadata":{"cpu_freq":"0=5100 MHz","cpu_temp":"coretemp:Package id 0=76 C, coretemp:Core 0=67 C","date":"2026-04-17 14:46:14.380431","duration":0.638255352008855,"load_avg_1min":2.45,"mem_max_rss":24838144,"runnable_threads":1,"uptime":202728.382250309},"values":[0.00012438162966645904,0.00012237902187735018,0.00012061590389293997],"warmups":[[64,0.00012253898360086167]]},{"metadata":{"cpu_freq":"0=5000 MHz","cpu_temp":"coretemp:Package id 0=66 C, coretemp:Core 0=66 C","date":"2026-04-17 14:46:15.067237","duration":0.6302964159986004,"load_avg_1min":2.45,"mem_max_rss":24838144,"runnable_threads":2,"uptime":202729.06895804405},"values":[0.0001214333453162908,0.00012213825782509958,0.00012049875938373589],"warmups":[[64,0.00011974951094089193]]}]}],"metadata":{"aslr":"Full randomization","boot_time":"2026-04-15 06:27:26","cpu_affinity":"0","cpu_config":"0=driver:intel_pstate, intel_pstate:turbo, governor:powersave; idle:intel_idle","cpu_count":24,"cpu_model_name":"12th Gen Intel(R) Core(TM) i9-12900K","hostname":"server0","perf_version":"2.10.0","performance_version":"1.14.0","platform":"Linux-7.0.0-13-generic-x86_64-with-glibc2.43","unit":"second"},"version":"1.0"} diff --git a/Misc/marshal-perf-diary.md b/Misc/marshal-perf-diary.md index a15db951a2f951..04c393908e6b8d 100644 --- a/Misc/marshal-perf-diary.md +++ b/Misc/marshal-perf-diary.md @@ -506,6 +506,84 @@ Correctness: `./python -m test test_marshal` passes (72 run / 7 skipped). only one we'd add without reservation is a properly-validated Exp 4 — once there is a benchmark that actually exercises back-refs. +## Final validation (post-squash HEAD `4aaf064344d`) + +After squashing the combined stack (Exp 1+2+6+7) onto +`marshal-safe-cycle-design`, the following validation ran. + +### Full CPython test suite + + ./python -m test -j24 --timeout=600 -w + +Result: **SUCCESS**. + +- 468 test files OK, 0 failures. +- 48,932 individual tests executed. +- 2,890 tests skipped (platform-specific: Windows/Apple/Android/Tk, + resource-gated, free-threading). +- Total wall time: 1 min 48 sec. +- All four new `RecursiveGraphTest` cases — the 156-program bounded + semantic round-trip generator, the case-count check, the handpicked + payloads, and the crafted-invalid-payload negative tests — pass. + +### `pyperformance` targeted slice vs `main` + +Ten marshal-adjacent benchmarks (same slice the original design-doc +rerun used): pickle, pickle_dict, pickle_list, pickle_pure_python, +python_startup, python_startup_no_site, unpack_sequence, unpickle, +unpickle_list, unpickle_pure_python. Run with +`uvx pyperformance run -b `, `taskset -c 0`, default +(non-rigorous) loop count, per-benchmark venv. + +| Benchmark | `main` | HEAD | Delta | Significance | +| --- | ---: | ---: | ---: | --- | +| `pickle` | `7.19 us +- 0.38 us` | `7.06 us +- 0.07 us` | `1.02x faster` | not significant | +| `pickle_dict` | `16.4 us +- 0.2 us` | `16.5 us +- 0.3 us` | `1.00x slower` | not significant | +| `pickle_list` | `2.66 us +- 0.06 us` | `2.68 us +- 0.06 us` | `1.01x slower` | not significant | +| `pickle_pure_python` | `185 us +- 2 us` | `186 us +- 3 us` | `1.01x slower` | not significant | +| **`python_startup`** | `7.88 ms +- 0.25 ms` | `6.70 ms +- 0.12 ms` | **`1.18x faster`** | **significant (t=59.80)** | +| **`python_startup_no_site`** | `4.34 ms +- 0.13 ms` | `4.19 ms +- 0.09 ms` | **`1.03x faster`** | **significant (t=12.90)** | +| `unpack_sequence` | `20.4 ns +- 0.4 ns` | `20.4 ns +- 0.3 ns` | `1.00x faster` | not significant | +| `unpickle` | `8.70 us +- 0.12 us` | `8.60 us +- 0.14 us` | `1.01x faster` | not significant | +| `unpickle_list` | `2.65 us +- 0.03 us` | `2.69 us +- 0.03 us` | `1.01x slower` | not significant | +| `unpickle_pure_python` | `121 us +- 3 us` | `122 us +- 3 us` | `1.00x slower` | not significant | + +Two statistically significant wins, both on startup. No regressions. + +The 18% `python_startup` speedup is real and user-visible: +interpreter startup loads a large number of `.pyc` files through +`marshal.loads`, so the hot-path improvements land on every Python +invocation. `python_startup_no_site` is smaller (3%) because it skips +the site module's imports, leaving less marshal work in the budget. + +Raw JSON: `Misc/marshal-perf-data/pyperf-slice-{baseline,current}.json`. +Reproduce with `uvx pyperformance compare` on the two files. + +### Marshal microbench on post-squash HEAD + +Three pinned best-of-median runs, same harness as every other experiment. + +| Bench | Op | `main` | HEAD `4aaf064` | vs `main` | +| --- | --- | ---: | ---: | ---: | +| `small_tuple` | `loads` | 0.0289962 | 0.0248193 | **−14.4%** | +| `small_tuple` | `dumps` | 0.0158760 | 0.0152102 | −4.2% | +| `nested_dict` | `loads` | 0.0778896 | 0.0721462 | **−7.4%** | +| `nested_dict` | `dumps` | 0.0722451 | 0.0722497 | flat | +| `code_obj` | `loads` | 0.0902017 | 0.0839155 | **−7.0%** | +| `code_obj` | `dumps` | 0.0391339 | 0.0385998 | −1.4% | + +Raw JSON: `Misc/marshal-perf-data/final-head-run{1,2,3}.json`. + +### Summary + +- Regression introduced by the safe-cycle design is fully erased on the + marshal microbench. +- `loads` is **7–14% faster than `main`** on all three microbenches. +- `pyperformance`'s marshal-adjacent slice shows one 18% startup win and + no regressions. +- Full CPython test suite passes, including the new combinatoric + recursive-graph generator. + ## Final conclusions ### Recommended stack From 4c18f3a8a70184577c0b46d51532341b3615e541 Mon Sep 17 00:00:00 2001 From: Michael Bommarito Date: Fri, 17 Apr 2026 15:07:57 -0400 Subject: [PATCH 6/6] marshal: add third-party + fuzz validation section to perf diary MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Records the outcome of an independent-library validation pass: - dill 0.4.1 test suite (30 files) — identical 29/30 pass on baseline and HEAD; the single failure is a pre-existing 3.15a8 incompatibility in dill's module-state serialization, unrelated to marshal. - cloudpickle 3.1.2 test suite (upstream) — 243/243 pass on both, identical skip/xfail breakdown. - 1,601 marshal-adjacent stdlib tests (test_importlib, test_zipimport, test_compileall, test_py_compile, test_marshal) all pass on HEAD. - compileall of CPython Lib/: +1.0% (within noise; dumps path untouched). - Cold-import stress (56 stdlib modules, fresh subprocess): flat. - Hypothesis fuzz (3500 random round-trips including cyclic shapes through mutable bridges): zero correctness regressions; acyclic round-trip -10%, list self-cycle -24%, dict value self-cycle -40%. Nothing in the third-party validation hints at a correctness or performance regression; several workloads that directly exercise the changed code path are measurably faster. Co-Authored-By: Claude Opus 4.7 (1M context) --- Misc/marshal-perf-diary.md | 101 +++++++++++++++++++++++++++++++++++++ 1 file changed, 101 insertions(+) diff --git a/Misc/marshal-perf-diary.md b/Misc/marshal-perf-diary.md index 04c393908e6b8d..7efc21f4f460c7 100644 --- a/Misc/marshal-perf-diary.md +++ b/Misc/marshal-perf-diary.md @@ -584,6 +584,107 @@ Raw JSON: `Misc/marshal-perf-data/final-head-run{1,2,3}.json`. - Full CPython test suite passes, including the new combinatoric recursive-graph generator. +## Third-party + fuzz validation + +To catch regressions that stdlib tests might miss, run the same HEAD +through libraries that exercise marshal heavily, plus property-based +fuzz. + +### Tier 1 — direct third-party marshal users + +Both tested on `/tmp/stress-venv-base` (main) and `/tmp/stress-venv` +(HEAD) via `taskset -c 0-7`. + +**`dill==0.4.1`** — explicitly uses `marshal.dumps`/`loads` to +serialize code objects; test suite is 30 files. + +| Outcome | baseline | HEAD | +| --- | --- | --- | +| Pass | 29 / 30 | 29 / 30 | +| Fail | 1 / 30 (`test_session`, pre-existing 3.15a8 issue in dill's module-state serialization — unrelated to marshal) | 1 / 30 (same) | +| Wall time | 2.15 s | 2.14 s | + +`test_recursive` and `test_objects` both pass — those are the tests +that touch our exact changed codepath. + +**`cloudpickle==3.1.2`** — pickles code objects via marshal; foundation +for Ray, Dask, joblib. Tests cloned from upstream. + +| Outcome | baseline | HEAD | +| --- | --- | --- | +| Pass | 243 | 243 | +| Skipped | 29 | 29 | +| xfail | 2 | 2 | +| Wall time | 9.50 s | 9.66 s | + +Identical pass rate and test breakdown. + +### Tier 2 — marshal-adjacent stdlib tests on HEAD + +| Test file | Tests | Result | +| --- | ---: | --- | +| `test_importlib.*` | 1,217 | SUCCESS | +| `test_zipimport` | 133 | SUCCESS | +| `test_compileall` | 145 | SUCCESS | +| `test_py_compile` | 34 | SUCCESS | +| `test_marshal` | 72 | SUCCESS | + +1,601 tests specifically covering `marshal.loads` / `marshal.dumps` +consumers. All green. + +### Tier 3 — real-world timing (cold cache) + +**compileall of CPython `Lib/`** (1944 `.py` files written to `.pyc` +via `marshal.dumps`, `__pycache__` wiped between runs, 3 runs each): + +| Python | Median | +| --- | ---: | +| baseline | 5.370 s | +| HEAD | 5.426 s | + ++1.0%, within noise. Expected — compileall is AST→bytecode dominated; +`marshal.dumps` is a small fraction, and the dumps path was not +touched. + +**Cold-import spectrum** (fresh subprocess imports 56 stdlib modules +in one shot, 15 repeats, trim 2 hi / 2 lo): + +| Python | Median | Trimmed mean | Min | +| --- | ---: | ---: | ---: | +| baseline | 99.82 ms | 99.69 ms | 96.82 ms | +| HEAD | 99.39 ms | 99.51 ms | 95.44 ms | + +Flat at median / mean, min improved 1.4%. Subprocess harness overhead +masks most of the ~1 ms startup saving here. + +### Tier 4 — Hypothesis property-based fuzz + +3,500 random round-trips with `hypothesis==6.152.1`, strategy covers +nested tuples / lists / dicts / frozensets / sets with 30-leaf +recursion depth, plus three hand-picked cyclic shapes: + +| Test | Examples | baseline | HEAD | Δ | +| --- | ---: | ---: | ---: | ---: | +| acyclic round-trip | 2,000 | 5.38 s | 4.84 s | **−10.0%** | +| list self-cycle | 500 | 0.33 s | 0.25 s | **−24%** | +| tuple via list bridge | 500 | 0.24 s | 0.26 s | +8% | +| dict value self-cycle | 500 | 0.35 s | 0.21 s | **−40%** | + +**All 3,500 cases pass on both — zero correctness regressions.** The +cyclic shapes (list self-cycle, dict value self-cycle) are precisely +what the safe-cycle design targets; they're faster on HEAD, not +slower. + +### Summary of third-party validation + +- **No correctness regressions found.** dill (29/30 identical), cloudpickle (243/243 identical), 1601 stdlib marshal-adjacent tests, 3500 hypothesis round-trips. +- **Measurable speedups** on marshal-heavy real workloads (hypothesis round-trip fuzz: −10 to −40% depending on shape). +- **Flat or within-noise** on workloads where marshal is only a small fraction (compileall writes, cold imports through subprocess harness). + +Taken together with the microbench and `pyperformance` results, the +change is safe to ship: every signal either gets faster or stays the +same. + ## Final conclusions ### Recommended stack