Possible memory leak in MultiIndex equals function
l am running a large computation, which is experiencing a memory leak that appears to be occurring in Pandas version 0.23.4. In total, the computation performs a large number of inner loops (it had performed ~85,000 when I stopped it due to ~50GB memory usage). At each inner loop, pandas reads a pickled dataframe labeled `running_df`, add-assigns the newly-computed `multiindex_df`, and saves the updated `running_df` as a pickle (overwriting the original pickle on disk). `running_df` and `multiindex_df` are both multi-indexed with the same row identities (hence how they can be added).

The computation is composed like:

```python
for i in outer_loop:
    for j in inner_loop:
        multiindex_df = # large computation goes here
        path = # get path for j
        if path.exists():
            # if not first outer loop iteration, update running_df
            running_df = pandas.read_pickle(path)
            running_df += multiindex_df
        else:
            running_df = multiindex_df
        running_df.to_pickle(path)
```

To diagnose the memory leak, I took [`tracemalloc`](https://docs.python.org/3/library/tracemalloc.html) snapshots at the end of the outer loop. I compared the final snapshot before I halted the execution to a snapshot from before the loop, using the `lineno` statistic. The top two results (which were far larger in size than anything else) were:

```
/home/dhimmel/anaconda3/envs/hetmech/lib/python3.6/site-packages/pandas/core/indexes/multi.py:2688: size=28.7 GiB (+28.7 GiB), count=1994546 (+1994546), average=15.1 KiB
/home/dhimmel/anaconda3/envs/hetmech/lib/python3.6/site-packages/pandas/core/indexes/multi.py:2683: size=28.7 GiB (+28.7 GiB), count=1992955 (+1992955), average=15.1 KiB
```

These lines both point to the `MultiIndex.equals` function of [`pandas/core/indexes/multi.py`](https://github.com/pandas-dev/pandas/blob/v0.23.4/pandas/core/indexes/multi.py#L2681-L2691). Specifically, the following lines:

```python
# pandas/core/indexes/multi.py:2683
slabels = slabels[slabels != -1]
# pandas/core/indexes/multi.py:2688
olabels = olabels[olabels != -1]
```

With a bit more context:

https://github.com/pandas-dev/pandas/blob/0409521665bd436a10aea7e06336066bf07ff057/pandas/core/indexes/multi.py#L2681-L2691

Here's the [link to the notebook](https://github.com/greenelab/hetmech/blob/484f36caa67909d21f6db41c9d68479181e25e06/explore/bulk-pipeline/bulk.ipynb) capturing the memory leak. It's still open on my machine (objects still in memory) should anyone have additional suggested diagnostic commands. This related source repo issue is https://github.com/greenelab/hetmech/issues/141.

I am new to memory leaks, but I am pretty sure our code is not retaining any references to these multi-indexes, so they should be getting garbage collected. Calling `gc.collect()` at the end of each outer loop does not effect the leakiness.