This feature is definitely big enough for a release note. Since we are planning this PR for just post-release, it should go under 0.5.1 "API Changes":

Okay, on first pass I like this. It seems straight forward, and I don't see any problems.

I'm going to hold off until Monday to give it a "final review", and hopefully merge it. #fingers-crossed

Nice work!

@drewj-tp - are there any immediate performance gains from this change that you can share in memory and/or speed? I like the idea of iterators, but I'm curious from a macroscopic perspective of managing the entire reactor how this propagates.

Thanks!

@drewj-tp - are there any immediate performance gains from this change that you can share in memory and/or speed? I like the idea of iterators, but I'm curious from a macroscopic perspective of managing the entire reactor how this propagates.

Thanks!

Good questions. I ran some tests on the FFTF model and, when traversing the entire reactor tree:

• 30x memory reduction
• 35% speed up

We'll still see some benefit if users don't migrate to the new iterChildren and still have large loops over r.getChildren(). With the new implementation, where getChildren(...) is basically list(c.iterChildren(...)), we get 18x memory reduction. The speed up is negligible and/or in the noise.

Note To see the real changes, I reverted the changes to Composite.getChildren to not use Composite.iterChildren. If you just checkout this branch, you'll likely see closer to the 18x memory reduction and negligible speed up.

import pathlib
import pickle

import armi

import tracemalloc

armi.configure()

pickleJar = pathlib.Path("fftf.pkl")
if pickleJar.exists():
    REACTOR = pickle.loads(pickleJar.read_bytes())
else:
    REACTOR = armi.init(fName="fftf/FFTF.yaml").r
    pickleJar.write_bytes(pickle.dumps(REACTOR))

tracemalloc.start()

for _ in REACTOR.getChildren(deep=True):
    pass

firstSize, firstPeak = tracemalloc.get_traced_memory()

tracemalloc.reset_peak()

for _ in REACTOR.iterChildren(deep=True):
    pass

secondSize, secondPeak = tracemalloc.get_traced_memory()


print(f"{firstSize=} :: {firstPeak=}")
print(f"{secondSize=} :: {secondPeak=}")
print(f"{firstSize/secondSize=} :: {firstPeak/secondPeak=}")

import pathlib
import pickle

import armi

import timeit

armi.configure()

pickleJar = pathlib.Path("fftf.pkl")
if pickleJar.exists():
    REACTOR = pickle.loads(pickleJar.read_bytes())
else:
    REACTOR = armi.init(fName="fftf/FFTF.yaml").r
    pickleJar.write_bytes(pickle.dumps(REACTOR))


def getChildren(r):
    list(r.getChildren(deep=True))

def iterChildren(r):
    list(r.iterChildren(deep=True))

N = 500

FAKE_GLOBALS = locals()

tGet = timeit.timeit("getChildren(REACTOR)", number=N, globals=FAKE_GLOBALS) / N

tIter = timeit.timeit("iterChildren(REACTOR)", number=N, globals=FAKE_GLOBALS) / N

print(f"{tGet=}")
print(f"{tIter=}")
print(f"{tIter/tGet=}")

• 30x memory reduction
• 35% speed up

That's awesome!

I would always argue strongly that you will get more performance improvements if/when we elbow the downstream repositories to start using these new tools.

Hell, we could grep around and open the PRs ourselves.

Just sayin.

I would always argue strongly that you will get more performance improvements if/when we elbow the downstream repositories to start using these new tools.

Hell, we could grep around and open the PRs ourselves

I have a follow on PR here that will help and then I'll start pinging projects on improvements

@drewj-tp Love it!

I have a few small questions for you, at your leisure.

But I love the feature. Assuming your downstream testing suite passes, I'm convinced.

Assuming your downstream testing suite passes, I'm convinced

Internal tests are passing!