PERF: concat perf

[TomAugspurger]

For Series[period], pd.concat is about 6x slower than PeriodArray._concat_same_type. There's always going to be some overhead, but I wonder how much we can narrow this.

In [1]: import numpy as np
   ...: import pandas as pd
   ...:
   ...: a = np.random.randint(2000, 2100, size=1000)
   ...: b = np.random.randint(2000, 2100, size=1000)
   ...:
   ...: x = pd.core.arrays.period_array(a, freq='B')
   ...: y = pd.core.arrays.period_array(b, freq='B')
   ...:
   ...: s = pd.Series(x)
   ...: t = pd.Series(y)


In [2]: %timeit pd.concat([s, t], ignore_index=True)
523 µs ± 22.6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [3]: %timeit x._concat_same_type([x, y])
90.1 µs ± 948 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

[qwhelan]

Based on my testing it seems this unfortunately isn't PeriodArray specific but instead a more general performance issue due to some unnecessary DataFrame creation when calling pd.concat() on only Series objects - I have a simple fix for one hot spot and am chasing down another now.

[TomAugspurger]

With #23404 we're down to 2x slower

In [4]: %timeit x._concat_same_type([x, y])
   ...:
99.8 µs ± 2.25 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [5]: %timeit pd.concat([s, t], ignore_index=True, copy=False)
   ...:
   ...:
194 µs ± 3.98 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

I looked very briefly at the snakeviz profile after that was merged. A decent chunk of it was in creating an Index. That's necessarily going to slow pd.concat down, but could perhaps be improved a bit.

[arw2019]

The difference on 1.2 master is 10x, although it looks like that's because of a significant (10x) improvement in PeriodArray._concat_same_type that hasn't been matched by the speed-up in pd.concat:

In [2]:  %timeit x._concat_same_type([x, y])                                                           
9.53 µs ± 29.5 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [3]:  %timeit pd.concat([s, t], ignore_index=True)                                                  
100 µs ± 2.59 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

[jbrockmendel]

Still very close to 12x on main following #52290 and #52291, but now those are 4 µs and 47 µs, respectively.

About 11% of the runtime of concat is in __finalize__, xref #51280. Other than that I'm out of ideas on optimizing this any further.