Drop extra type check in _extract_serialize

[jakirkham]

Currently _extract_serialize performs a type check on its arguments and then when walking through any collections it performs type checks on any values it encounters. If any of those values are collections, it effectively performs the same type check twice. Thus for more deeply nested structures, these additional type checks will add up for every layer. To fix this, we perform a type check on the arguments provided to extract_serialize and do a bit of preparation on the arguments to _extract_serialize. Additionally when looping over values in _extract_serialize, we leverage this one type check to do any other preparation we may need to do with that info. As a result we are able to eliminate this overhead.

Here's a rough benchmark showing the effect of this change:

Before:

In [1]: from distributed.protocol.serialize import extract_serialize

In [2]: data = 1_000_000 * b"abc"
   ...: msg = 11 * [10 * [2 * [5 * [data]]]]

In [3]: %timeit extract_serialize(msg)
943 µs ± 39 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

After:

In [1]: from distributed.protocol.serialize import extract_serialize

In [2]: data = 1_000_000 * b"abc"
   ...: msg = 11 * [10 * [2 * [5 * [data]]]]

In [3]: %timeit extract_serialize(msg)
786 µs ± 9.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

[jakirkham]

Also it is worth noting that this change of list construction is significantly faster on its own. By reducing the type checks performed, we are able to take advantage of this improvement by creating the list as we intend without filling up an existing list later.

In [1]: %%timeit l = []
   ...: l.extend(repeat(None, 100))
   ...: 
   ...: 
641 ns ± 7.04 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [2]: %%timeit l = []
   ...: l = 100 * [None]
   ...: 
   ...: 
348 ns ± 10.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

[mrocklin]

Fine by me