Core: Improve iteration speed of Region.Register objects

[Mysteryem]

What is this fixing or adding?

Without implementing __iter__ directly, calling iter() on a Region.Register on Python 3.12 would return a new generator implemented as follows:

        def __iter__(self) -> int:
            i = 0
            try:
                while True:
                    v = self[i]
                    yield v
                    i += 1
            except IndexError:
                return None

This was determined by disassembling the returned generator with dis.dis() and then constructing a function that disassembles into the same bytecode.

The iterator returned by iter(self._list) is faster than this generator, so using it slightly improves generation performance on average.

Iteration of Region.Register objects is used a lot in CollectionState.update_reachable_regions in both of the private _update methods that get called. The performance gain here will vary depending on how many regions a world has and how many exits those regions have on average.

For a game like Blasphemous, with a lot of regions and exits, generation of 10 template Blasphemous yamls with --skip_output --seed 1 and progression balancing disabled went from 19.0s to 16.4s (14.2% reduction in generation duration).

How was this tested?

Generations were run before and afterwards. Comparing duration and output of the same seeds.

[Mysteryem]

Bytecode printed from dis.dis(iter(world.get_region("Menu").exits)) on Python 3.12:

1022           0 RETURN_GENERATOR
               2 POP_TOP
               4 RESUME                   0

1023           6 LOAD_CONST               1 (0)
               8 STORE_FAST               1 (i)

1024          10 NOP

1025          12 NOP

1026     >>   14 LOAD_FAST                0 (self)
              16 LOAD_FAST                1 (i)
              18 BINARY_SUBSCR
              22 STORE_FAST               2 (v)

1027          24 LOAD_FAST                2 (v)
              26 YIELD_VALUE              2
              28 RESUME                   1
              30 POP_TOP

1028          32 LOAD_FAST                1 (i)
              34 LOAD_CONST               2 (1)
              36 BINARY_OP               13 (+=)
              40 STORE_FAST               1 (i)

1025          42 JUMP_BACKWARD           15 (to 14)
         >>   44 PUSH_EXC_INFO

1029          46 LOAD_GLOBAL              0 (IndexError)
              56 CHECK_EXC_MATCH
              58 POP_JUMP_IF_FALSE        3 (to 66)
              60 POP_TOP

1030          62 POP_EXCEPT
              64 RETURN_CONST             0 (None)

1029     >>   66 RERAISE                  0
         >>   68 COPY                     3
              70 POP_EXCEPT
              72 RERAISE                  1
         >>   74 CALL_INTRINSIC_1         3 (INTRINSIC_STOPITERATION_ERROR)
              76 RERAISE                  1
ExceptionTable:
  4 to 8 -> 74 [0] lasti
  12 to 42 -> 44 [0]
  44 to 60 -> 68 [1] lasti
  62 to 64 -> 74 [0] lasti
  66 to 66 -> 68 [1] lasti
  68 to 72 -> 74 [0] lasti

[Mysteryem]

From looking at the CPython source code, deque.extend() does not appear to implement any optimisations for being passed list/tuple objects (would use the https://docs.python.org/3/c-api/sequence.html#c.PySequence_Fast family of functions), so providing it a fast iterator is probably the best that can be done currently.

https://github.com/python/cpython/blob/3.12/Modules/_collectionsmodule.c#L413 (deque_extend_impl as of CPython 3.13)

Archipelago/BaseClasses.py

Line 775 in 1fe8024

queue.extend(new_region.exits)

Archipelago/BaseClasses.py

Lines 802 to 806 in 1fe8024

	queue.extend(new_region.exits)
	self.path[new_region] = (new_region.name, self.path.get(connection, None))
	new_connection = True
	# sweep for indirect connections, mostly Entrance.can_reach(unrelated_Region)
	queue.extend(blocked_connections)

[NewSoupVi]

Huh