gh-156548: Performance - Presize sets built from sized iterables

[brittanyrey]

set() and set.update() already presize their underlying containers when they can infer the expected container size from another set or dict, but they fall back to incremental growth for all other iterables.

Since we can also retrieve the size of lists and tuples, we can extend the same logic to sized iterables to reduce container resizing overhead. Iterables that have no clear size (i.e. generators) will remain unaffected.

For this PR, I first refactored the two existing explicit presize calls into a helper function to be shared for the sized iterables as well.

Benchmark	main	PR
set(list[str]) 10k	158 us	119 us: 1.32x faster
set(list[str]) 1M	88.2 ms	68.7 ms: 1.28x faster
set(tuple[str]) 1M	85.6 ms	66.9 ms: 1.28x faster
set(list[int]) 10k	117 us	95.3 us: 1.23x faster
set(list[int]) 1M	24.9 ms	20.6 ms: 1.21x faster
set(tuple[int]) 1M	23.8 ms	19.9 ms: 1.20x faster
set.update(list) 1M	24.2 ms	20.5 ms: 1.18x faster
frozenset(list) 1M	26.6 ms	22.6 ms: 1.18x faster
set(genexpr) 1M [no hint]	59.4 ms	60.3 ms: 1.02x slower

Note: In the no hint case, theres about a ~8ns fixed overhead to call PyObject_LengthHint and discard the output.

Benchmark script

"""set/frozenset built from a sized iterable (Objects/setobject.c)."""
import pyperf

def mkset(s): 
  set(s)

def mkfrozen(s): 
  frozenset(s)

def upd(s): 
  d = set(); d.update(s)

def gen(n): 
  set(x for x in range(n))

if __name__ == "__main__":
    r = pyperf.Runner()
    ints = list(range(1000000)); strs = [str(i) for i in ints]
    r.bench_func("set(list[int]) 1M", mkset, ints)
    r.bench_func("set(list[str]) 1M", mkset, strs)
    r.bench_func("frozenset(list) 1M", mkfrozen, ints)
    r.bench_func("set.update(list) 1M", upd, ints)
    r.bench_func("set(list) 10k", mkset, list(range(10000)))
    r.bench_func("set(genexpr) 1M [no hint]", gen, 1000000)

• Issue: Performance: Expand use of presizing in sets to include more sized iterables #156548

[pochmann]

List elements aren't expected to be unique, though. I'd say a major use case for turning a list into a set is precisely that you do have duplicates (and want to remove them). So your tests with lists of only unique elements seem rather unrealistic.

[brittanyrey]

I'm going to abandon this one