MAINT: patch UNU.RAN to fix all the potential memory leaks

[tirthasheshpatel]

@mckib2

scipy/scipy#14215

I have added a Python script to help find memory leaks in a window under UNU.RAN checks. Before applying these changes, it reported around 50 leaks. Now, it reports around 18 leaks with window size 6 but most of them are:

• false positives
• not used or will ever be used in SciPy

I have fixed all the leaks under modules discr, distribution, methods, tests, parser, and utils. We currently don't use much of this code but we should be able to safely use it in the future if we want to with there changes.

Run the Python script to get all the errors: python3 find_memory_leaks.py -v --window-size 6 To store the output in a file, do: python3 find_memory_leaks.py --window-size 6 --output leaks.txt

[mckib2]

This looks great @tirthasheshpatel ! If you've verified that the scipy UNU.RAN test pass with these changes (and no crashes, etc.), I think it's good to merge and update the submodule reference.

Have you tried running any tests/examples of the SciPy wrappers with valgrind? That might help identify what the issues actually are

[tirthasheshpatel]

Thanks for looking into this, @mckib2! I verified that this builds with SciPy and also ran valgrind on simple test scripts. Thankfully, it doesn't report any leaks in UNU.RAN or the wrapper!

Code I used to check leaks with valgrind

```py from scipy.stats import TransformedDensityRejection, DiscreteAliasUrn import numpy as np from math import exp class StandardNormal: def pdf(self, x): return exp(-0.5 * x*x) def dpdf(self, x): return -x * exp(-0.5 * x*x) dist = StandardNormal() rng = TransformedDensityRejection(dist, max_sqhratio=0.99999, max_intervals=100000, seed=123, guide_factor=10) rvs = rng.rvs(10000) u = np.linspace(0, 1, num=100000) ppf_hat = rng.ppf_hat(u) pv = 10000 * [0.5] rng = DiscreteAliasUrn(pv, urn_factor=10, seed=123) rvs = rng.rvs(100000) ``` Valgrind Leaks Summary: ```none ==13666== LEAK SUMMARY: ==13666== definitely lost: 1,088 bytes in 10 blocks ==13666== indirectly lost: 0 bytes in 0 blocks ==13666== possibly lost: 181,459 bytes in 107 blocks ==13666== still reachable: 3,416,723 bytes in 2,052 blocks ==13666== suppressed: 0 bytes in 0 blocks ``` The `1088 bytes` leak is not inside UNU.RAN. I checked with master and the same is present there too. Output log says it's something from `dlopen` library: ```none ==13666== 1,088 bytes in 10 blocks are definitely lost in loss record 661 of 893 ==13666== at 0x483B7F3: malloc (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so) ==13666== by 0x401676C: resize_scopes (dl-open.c:282) ==13666== by 0x401676C: dl_open_worker (dl-open.c:693) ==13666== by 0x49D18B7: _dl_catch_exception (dl-error-skeleton.c:208) ==13666== by 0x40155F9: _dl_open (dl-open.c:837) ==13666== by 0x4A8434B: dlopen_doit (dlopen.c:66) ==13666== by 0x49D18B7: _dl_catch_exception (dl-error-skeleton.c:208) ==13666== by 0x49D1982: _dl_catch_error (dl-error-skeleton.c:227) ==13666== by 0x4A84B58: _dlerror_run (dlerror.c:170) ==13666== by 0x4A843D9: dlopen@@GLIBC_2.2.5 (dlopen.c:87) ==13666== by 0x6B25A4: ??? (in /usr/bin/python3.9) ==13666== by 0x6C1E8D: ??? (in /usr/bin/python3.9) ==13666== by 0x52648C: ??? (in /usr/bin/python3.9) ```

[tirthasheshpatel]

I might want to take back what I said earlier. Apparently, when I run valgrind with pytest scipy/stats/tests/test_sampling.py, it gives me lots of errors in UNU.RAN :(

==25301== LEAK SUMMARY:
==25301==    definitely lost: 13,728 bytes in 58 blocks
==25301==    indirectly lost: 43,520 bytes in 387 blocks
==25301==      possibly lost: 166,439 bytes in 114 blocks
==25301==    still reachable: 3,553,979 bytes in 2,254 blocks
==25301==         suppressed: 0 bytes in 0 blocks

[tirthasheshpatel]

I ran valgrind again after removing all the nonlocal returns and it reported no leaks. Turns out this is more complicated than I thought. I will have to rethink a way to handle errors. Sorry for all the mess!! Closing this and marking the PR on scipy draft again until this is done.