gh-121192: Add fast path to deepcopy() for empty list/tuple/dict/set

[lgeiger]

deepcopy() can be surprisingly slow when called with empty containers like lists, tuples, dicts, sets or frozensets.

This adds a fast path for this case similar to #114266 which speeds up these cases by about 4x - 21x while having a small impact on the default path.

Here are some benchmarks comparing this PR against main. Let me know if there are more benchmarks that I can run to verify that there a no performance regressions for the common case:

importpyperfrunner=pyperf.Runner()
setup="""import copya = {"list": [1, 2 ,3 ,4], "t": (1, 2, 3), "str": "hello", "subdict": {"a": True}}t = ()fs = frozenset()l = []s = set()d = {}deep = [[], (), {}, set(), frozenset()]"""runner.timeit(name="deepcopy dict", stmt=f"b = copy.deepcopy(a)", setup=setup)
runner.timeit(name="deepcopy empty tuple", stmt=f"b = copy.deepcopy(t)", setup=setup)
runner.timeit(name="deepcopy empty frozenset", stmt=f"b = copy.deepcopy(fs)", setup=setup)
runner.timeit(name="deepcopy empty list", stmt=f"b = copy.deepcopy(l)", setup=setup)
runner.timeit(name="deepcopy empty set", stmt=f"b = copy.deepcopy(s)", setup=setup)
runner.timeit(name="deepcopy empty dict", stmt=f"b = copy.deepcopy(d)", setup=setup)
runner.timeit(name="deepcopy multiple empty containers", stmt=f"b = copy.deepcopy(deep)", setup=setup)

deepcopy empty tuple: Mean +- std dev: [baseline] 287 ns +- 4 ns -> [opt-empty] 49.8 ns +- 1.7 ns: 5.77x faster
deepcopy empty frozenset: Mean +- std dev: [baseline] 1.46 us +- 0.02 us -> [opt-empty] 67.1 ns +- 1.8 ns: 21.70x faster
deepcopy empty list: Mean +- std dev: [baseline] 327 ns +- 6 ns -> [opt-empty] 67.1 ns +- 8.2 ns: 4.88x faster
deepcopy empty set: Mean +- std dev: [baseline] 1.44 us +- 0.02 us -> [opt-empty] 67.9 ns +- 3.8 ns: 21.26x faster
deepcopy empty dict: Mean +- std dev: [baseline] 329 ns +- 4 ns -> [opt-empty] 68.1 ns +- 3.0 ns: 4.83x faster
Benchmark hidden because not significant (2): deepcopy dict, deepcopy multiple empty containers
Geometric mean: 4.85x faster

• Issue: Add fast path to deepcopy() for empty list/tuple/dict/set #121192

[lgeiger]

I ran the relevant pyperformance deepcopy benchmark which does seem to suggest that this change makes the non empty case slightly slower:EDIT: I re-ran the pyperformance benchmarks with the latest changes in d87901e and I now can't see any performance regression for the common case.

Performance version: 1.11.0
Python version: 3.14.0a0 (64-bit) revision 1a84bdc237
Report on macOS-14.5-arm64-arm-64bit-Mach-O
Number of logical CPUs: 8
Start date: 2024-07-02 01:23:14.690599
End date: 2024-07-02 01:23:51.844329
### deepcopy ###
Mean +- std dev: 123 us +- 12 us -> 120 us +- 1 us: 1.03x faster
Significant (t=2.25)
### deepcopy_memo ###
Mean +- std dev: 14.1 us +- 0.2 us -> 14.1 us +- 0.3 us: 1.00x slower
Not significant
### deepcopy_reduce ###
Mean +- std dev: 1.22 us +- 0.06 us -> 1.21 us +- 0.01 us: 1.00x faster
Not significant

[eendebakpt]

The optimization applied in the latest iteration of the PR is only applied when no memo is passed to deepcopy. The advantage is that any recursive structures like {'a': [1, 2, 3, 4, ,5]} will have no (or near zero) overhead. So I agree that performance regression for many common cases is not a big concern.

The question then is whether a deepcopy directly on an empty builtin like like and set (and not a deepcopy on a recursive structure containing empty builtins, e.g, ( {}, [], ())) is a common enough operation to apply this PR. I am not convinced on this, In the corresponding issue an example is given for pydantic basemodels. But there the deepcopy overhead can be avoided by using a default factory. Also the corresponding situation for plain dataclasses cannot occur:

from dataclasses import dataclass
@dataclass
class DC:
a : list = []
x=DC()

raises a ValueError: mutable default <class 'list'> for field a is not allowed: use default_factory. With attrs an empty list is allowed, but no deepcopy is performed on instantiation. For example

import attrs
@attrs.define
class DC:
a : list = []
x=DC()
y=DC()
x.a.append(1)
print(x)
print(y)

results in

DC(a=[1])
DC(a=[1])

[eendebakpt]

For reference: I performed a benchmark of main, this PR and the deepcopy C implementation from #91610. On benchmark

import pyperf
runner = pyperf.Runner()
setup="""
import copy
from dataclasses import dataclass
@dataclass
class A:
a : list
b : str
c : bool
d: tuple
e : set
dc=A([1,2,3], 'hello', True, (), {})
empty_tuple = tuple()
empty_list = []
"""
runner.timeit(name="deepcopy empty tuple", stmt="b=copy.deepcopy(empty_tuple)", setup=setup)
runner.timeit(name="deepcopy empty list", stmt="b=copy.deepcopy(empty_list)", setup=setup)
runner.timeit(name="deepcopy dataclass", stmt="b=copy.deepcopy(dc)", setup=setup)

Results are

deepcopy empty tuple: Mean +- std dev: [dc_main] 827 ns +- 37 ns -> [dc_fastpath_empty] 203 ns +- 7 ns: 4.06x faster
deepcopy empty list: Mean +- std dev: [dc_main] 1.00 us +- 0.09 us -> [dc_fastpath_empty] 233 ns +- 24 ns: 4.29x faster
deepcopy dataclass: Mean +- std dev: [dc_main] 8.02 us +- 0.12 us -> [dc_fastpath_empty] 8.22 us +- 0.07 us: 1.02x slower
Geometric mean: 2.57x faster

(env312) c:\projects\misc\cpython\PCbuild>python -m pyperf compare_to dc_main.json dc_c.json
deepcopy empty tuple: Mean +- std dev: [dc_main] 827 ns +- 37 ns -> [dc_c] 90.6 ns +- 9.8 ns: 9.13x faster
deepcopy empty list: Mean +- std dev: [dc_main] 1.00 us +- 0.09 us -> [dc_c] 216 ns +- 24 ns: 4.63x faster
deepcopy dataclass: Mean +- std dev: [dc_main] 8.02 us +- 0.12 us -> [dc_c] 4.06 us +- 0.43 us: 1.97x faster
Geometric mean: 4.37x faster

[sobolevn]

@eendebakpt it can happen for dataclass, example:

fromdataclassesimportdataclass, as_dict@dataclassclassSome:
field: set[int]
as_dict(Some(set()))

[eendebakpt]

@eendebakpt it can happen for dataclass, example:

Indeed. Here a more complete example, including the cases where this PR helps

from dataclasses import dataclass, asdict
@dataclass class Some:
a: str
t: tuple[int]
field: set[int] # benefits
l : list[int]
d : dict[str, str]
fs: frozenset[int] # benefits
nonempty : set[int]
s=Some('x', tuple(), set(), [], d={}, fs=frozenset(), nonempty={1, 2})
asdict(s)

[lgeiger]

Indeed. Here a more complete example, including the cases where this PR helps

Thanks for the example! This PR indeed shows a decent improvement here:

importpyperfrunner=pyperf.Runner()
setup="""from dataclasses import dataclass, asdict@dataclassclass Some: a: str t: tuple[int] field: set[int] # benefits l : list[int] d : dict[str, str] fs: frozenset[int] # benefits nonempty : set[int]s = Some('x', tuple(), set(), [], d={}, fs=frozenset(), nonempty={1, 2})"""runner.timeit(name="dataclass asdict", stmt=f"b = asdict(s)", setup=setup)

Mean +- std dev: [asdict-baseline] 6.26 us +- 0.07 us -> [asdict-opt] 3.39 us +- 0.18 us: 1.85x faster

[sobolevn]

Other use-cases that we can find in our own code:

• dataclass:

  cpython/Lib/dataclasses.py

  Line 1487 in 26d24ee

  returncopy.deepcopy(obj)

  also as_tuple for set and frozenset
• weakref: WeakValueDictionary

  cpython/Lib/weakref.py

  Line 191 in 26d24ee

  new[deepcopy(key, memo)] =o

  and WeakKeyDictionary:

  cpython/Lib/weakref.py

  Line 448 in 26d24ee

  new[o] =deepcopy(value, memo)

  where values can be any of the given types, and keys can be empty tuples and empty frozendicts (which is rather rare, I agree)
• http:

  cpython/Lib/http/cookiejar.py

  Line 1819 in 26d24ee

  old_state=copy.deepcopy(self._cookies)

  where self._cookies is empty by default

  cpython/Lib/http/cookiejar.py

  Line 1267 in 26d24ee

  self._cookies= {}

• coping nested structures where keys/values are empty collections, like: {'data': []}

[github-actions]

This PR is stale because it has been open for 30 days with no activity.

[eendebakpt]

I do not think the fast path is worth the case here. Better alternatives would be to create a C version of deepcopy or use an external package like https://github.com/percolab/copium.