⚡️ Speed up function create_filled_image by 12%

[codeflash-ai]

📄 12% (0.12x) speedup for create_filled_image in invokeai/backend/image_util/infill_methods/tile.py

⏱️ Runtime : 3.31 milliseconds → 2.95 milliseconds (best of 191 runs)

📝 Explanation and details

The optimized code achieves a 12% speedup by eliminating expensive random number generation from the inner loop. The key optimization is batch generation of all random tile indices in a single vectorized call (rng.integers(len(tile_pool), size=(num_tiles_y, num_tiles_x))), replacing hundreds of individual RNG calls that were consuming 26.9% of the original execution time.

Key changes:

• Pre-computes tile grid coordinates (y_coords, x_coords) to avoid repeated range operations
• Generates all random tile indices upfront in one vectorized operation, reducing Python/NumPy overhead
• Moves space calculations (space_y, space_x) outside the inner loop where possible to minimize redundant computations

Performance impact:
The optimization is most effective for large-scale test cases where many tiles are placed. Test results show 32-69% speedups for large images (100x100+ pixels), while smaller images see 15-27% slowdowns due to setup overhead. This suggests the function is likely called on substantial images where the vectorized RNG approach pays off significantly.

The batch RNG generation transforms O(tiles) random calls into O(1), making the optimization particularly valuable when filling large images with many tile positions, which appears to be the primary use case based on the test performance patterns.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 38 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Generated Regression Tests and Runtime

import numpy as np
# imports
import pytest
from invokeai.backend.image_util.infill_methods.tile import create_filled_image

# unit tests

# -------------------- Basic Test Cases --------------------

def test_basic_single_tile_exact_fit():
    # Image is 4x4, tile is 4x4, only one tile in pool, should fill with that tile
    img = np.zeros((4,4,3), dtype=np.uint8)
    tile = np.ones((4,4,3), dtype=np.uint8) * 123
    codeflash_output = create_filled_image(img, [tile], (4,4), 42); result = codeflash_output # 61.3μs -> 77.8μs (21.3% slower)

def test_basic_multiple_tiles_reproducibility():
    # 4x4 image, 2x2 tiles, two different tiles, check reproducibility with seed
    img = np.zeros((4,4,3), dtype=np.uint8)
    tile1 = np.ones((2,2,3), dtype=np.uint8) * 10
    tile2 = np.ones((2,2,3), dtype=np.uint8) * 20
    codeflash_output = create_filled_image(img, [tile1, tile2], (2,2), 123); result1 = codeflash_output # 56.4μs -> 67.0μs (15.7% slower)
    codeflash_output = create_filled_image(img, [tile1, tile2], (2,2), 123); result2 = codeflash_output # 29.6μs -> 36.6μs (18.9% slower)

def test_basic_tile_smaller_than_image():
    # 6x6 image, 3x3 tile, tile pool of one, should repeat tile 4 times
    img = np.zeros((6,6,3), dtype=np.uint8)
    tile = np.arange(27, dtype=np.uint8).reshape(3,3,3)
    codeflash_output = create_filled_image(img, [tile], (3,3), 1); result = codeflash_output # 49.6μs -> 61.2μs (19.0% slower)
    # Each 3x3 block should match the tile
    for y in [0,3]:
        for x in [0,3]:
            pass

def test_basic_tile_pool_multiple_colors():
    # 2x2 image, 1x1 tiles, 3 colored tiles, check that all possible outputs are from tiles
    img = np.zeros((2,2,3), dtype=np.uint8)
    tile_pool = [np.full((1,1,3), i, dtype=np.uint8) for i in [10, 20, 30]]
    codeflash_output = create_filled_image(img, tile_pool, (1,1), 99); result = codeflash_output # 48.7μs -> 59.6μs (18.3% slower)
    # All pixels must be one of the tile values
    unique_vals = np.unique(result)
    for val in unique_vals:
        pass

# -------------------- Edge Test Cases --------------------


def test_edge_tile_larger_than_image():
    # Tile is larger than image, should crop tile to fit
    img = np.zeros((2,2,3), dtype=np.uint8)
    tile = np.arange(60, 72, dtype=np.uint8).reshape(3,4,1).repeat(3, axis=2)
    codeflash_output = create_filled_image(img, [tile], (4,3), 0); result = codeflash_output # 40.3μs -> 55.9μs (27.8% slower)
    # The result should be the top-left 2x2 of the tile
    expected = tile[:2,:2,:]

def test_edge_empty_tile_pool():
    # Should raise IndexError if tile pool is empty
    img = np.zeros((2,2,3), dtype=np.uint8)
    with pytest.raises(ValueError):
        # We expect this to fail, but the original code would raise IndexError
        # Let's check for ValueError for better practice
        create_filled_image(img, [], (1,1), 0) # 55.1μs -> 60.5μs (8.78% slower)

def test_edge_incorrect_tile_shape():
    # Tile with wrong shape (e.g., missing channels)
    img = np.zeros((2,2,3), dtype=np.uint8)
    tile = np.ones((2,2), dtype=np.uint8)  # Missing color channel
    with pytest.raises(IndexError):
        create_filled_image(img, [tile], (2,2), 0) # 41.9μs -> 55.5μs (24.5% slower)

def test_edge_non_rgb_image():
    # Non-RGB image (e.g., 4 channels)
    img = np.zeros((4,4,4), dtype=np.uint8)
    tile = np.ones((2,2,3), dtype=np.uint8) * 42
    # Should work, only fills the first 3 channels
    codeflash_output = create_filled_image(img, [tile], (2,2), 0); result = codeflash_output # 52.2μs -> 63.3μs (17.4% slower)

# -------------------- Large Scale Test Cases --------------------

def test_large_scale_maximum_tiles():
    # 100x100 image, 10x10 tile, 10 different tiles
    img = np.zeros((100,100,3), dtype=np.uint8)
    tile_pool = [np.full((10,10,3), i, dtype=np.uint8) for i in range(10)]
    codeflash_output = create_filled_image(img, tile_pool, (10,10), 555); result = codeflash_output # 243μs -> 158μs (54.0% faster)
    # All pixels must be one of the tile values
    unique_vals = np.unique(result)
    for val in unique_vals:
        pass

def test_large_scale_randomness_and_seed():
    # 50x50 image, 5x5 tile, 5 tiles, check that different seeds give different outputs
    img = np.zeros((50,50,3), dtype=np.uint8)
    tile_pool = [np.full((5,5,3), i*50, dtype=np.uint8) for i in range(5)]
    codeflash_output = create_filled_image(img, tile_pool, (5,5), 1); result1 = codeflash_output # 246μs -> 164μs (50.2% faster)
    codeflash_output = create_filled_image(img, tile_pool, (5,5), 2); result2 = codeflash_output # 218μs -> 129μs (68.8% faster)

def test_large_scale_performance():
    # 200x200 image, 20x20 tile, 4 tiles, ensure reasonable performance and correct output shape
    img = np.zeros((200,200,3), dtype=np.uint8)
    tile_pool = [np.full((20,20,3), i*40, dtype=np.uint8) for i in range(4)]
    codeflash_output = create_filled_image(img, tile_pool, (20,20), 42); result = codeflash_output # 253μs -> 167μs (51.8% faster)

def test_large_scale_tile_cropping_at_edges():
    # 99x99 image, 10x10 tile, tile pool of one, check that bottom/right edges are cropped
    img = np.zeros((99,99,3), dtype=np.uint8)
    tile = np.arange(300, dtype=np.uint8).reshape(10,10,3)
    codeflash_output = create_filled_image(img, [tile], (10,10), 0); result = codeflash_output # 241μs -> 159μs (50.9% faster)
    # Bottom-right corner should be cropped
    expected = tile[:9,:9,:]

# -------------------- Mutation Testing: Defensive Tests --------------------

def test_mutation_tile_selection():
    # If tile selection is not random or not using the seed, output will always be the same
    img = np.zeros((6,6,3), dtype=np.uint8)
    tile1 = np.ones((3,3,3), dtype=np.uint8) * 1
    tile2 = np.ones((3,3,3), dtype=np.uint8) * 2
    # Two different seeds must yield different outputs
    codeflash_output = create_filled_image(img, [tile1, tile2], (3,3), 123); res1 = codeflash_output # 50.9μs -> 60.8μs (16.2% slower)
    codeflash_output = create_filled_image(img, [tile1, tile2], (3,3), 456); res2 = codeflash_output # 29.0μs -> 35.8μs (19.0% slower)

def test_mutation_tile_cropping():
    # If tile is not cropped properly, edge blocks will be wrong shape
    img = np.zeros((5,5,3), dtype=np.uint8)
    tile = np.ones((3,3,3), dtype=np.uint8) * 99
    codeflash_output = create_filled_image(img, [tile], (3,3), 0); result = codeflash_output # 46.5μs -> 57.8μs (19.5% slower)

def test_mutation_channel_handling():
    # If code doesn't handle 3 channels correctly, output shape may be wrong
    img = np.zeros((4,4,3), dtype=np.uint8)
    tile = np.ones((2,2,4), dtype=np.uint8) * 5  # 4 channels, but only first 3 should be used
    codeflash_output = create_filled_image(img, [tile], (2,2), 0); result = codeflash_output # 47.1μs -> 56.3μs (16.3% slower)

def test_mutation_dtype_preservation():
    # Output dtype should match input image dtype
    img = np.zeros((4,4,3), dtype=np.float32)
    tile = np.ones((2,2,3), dtype=np.float32) * 0.5
    codeflash_output = create_filled_image(img, [tile], (2,2), 0); result = codeflash_output # 46.7μs -> 58.2μs (19.8% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import numpy as np  # required for image and tile manipulation
# imports
import pytest  # used for our unit tests
from invokeai.backend.image_util.infill_methods.tile import create_filled_image

# unit tests

# -------------------- Basic Test Cases --------------------

def test_basic_single_tile_fills_exact_image():
    # Test with a single tile that exactly matches the image size
    img = np.zeros((4, 4, 3), dtype=np.uint8)
    tile = np.ones((4, 4, 3), dtype=np.uint8) * 255
    codeflash_output = create_filled_image(img, [tile], (4, 4), seed=42); result = codeflash_output # 62.9μs -> 80.6μs (21.9% slower)

def test_basic_multiple_tiles_randomness_and_seed():
    # Test with multiple tiles and check reproducibility with seed
    img = np.zeros((4, 4, 3), dtype=np.uint8)
    tile1 = np.ones((2, 2, 3), dtype=np.uint8) * 100
    tile2 = np.ones((2, 2, 3), dtype=np.uint8) * 200
    pool = [tile1, tile2]
    codeflash_output = create_filled_image(img, pool, (2, 2), seed=123); result1 = codeflash_output # 58.6μs -> 69.1μs (15.3% slower)
    codeflash_output = create_filled_image(img, pool, (2, 2), seed=123); result2 = codeflash_output # 29.7μs -> 36.6μs (18.8% slower)
    # Check that all values are either 100 or 200
    unique_vals = np.unique(result1)

def test_basic_tile_smaller_than_image():
    # Image is larger than tile, should repeat tiles
    img = np.zeros((4, 4, 3), dtype=np.uint8)
    tile = np.ones((2, 2, 3), dtype=np.uint8) * 50
    codeflash_output = create_filled_image(img, [tile], (2, 2), seed=1); result = codeflash_output # 49.8μs -> 60.6μs (17.8% slower)

def test_basic_tile_pool_with_different_tiles():
    # Pool contains tiles with distinct values, check that all are present
    img = np.zeros((4, 4, 3), dtype=np.uint8)
    tile1 = np.ones((2, 2, 3), dtype=np.uint8) * 10
    tile2 = np.ones((2, 2, 3), dtype=np.uint8) * 20
    tile3 = np.ones((2, 2, 3), dtype=np.uint8) * 30
    codeflash_output = create_filled_image(img, [tile1, tile2, tile3], (2, 2), seed=99); result = codeflash_output # 49.2μs -> 60.1μs (18.0% slower)
    unique_vals = np.unique(result)

# -------------------- Edge Test Cases --------------------


def test_edge_tile_larger_than_image():
    # Tile is larger than the image; should crop tile to fit
    img = np.zeros((2, 2, 3), dtype=np.uint8)
    tile = np.ones((4, 4, 3), dtype=np.uint8) * 88
    codeflash_output = create_filled_image(img, [tile], (4, 4), seed=5); result = codeflash_output # 63.9μs -> 80.9μs (21.0% slower)

def test_edge_empty_tile_pool_raises():
    # No tiles in pool should raise IndexError
    img = np.zeros((4, 4, 3), dtype=np.uint8)
    with pytest.raises(ValueError):
        # We expect ValueError or IndexError, but the code will throw IndexError
        create_filled_image(img, [], (2, 2), seed=42) # 62.3μs -> 68.4μs (8.84% slower)

def test_edge_tile_with_extra_channels():
    # Tile with more than 3 channels; should ignore extra channels
    img = np.zeros((4, 4, 3), dtype=np.uint8)
    tile = np.ones((2, 2, 5), dtype=np.uint8) * 123
    codeflash_output = create_filled_image(img, [tile], (2, 2), seed=7); result = codeflash_output # 56.8μs -> 67.1μs (15.3% slower)

def test_edge_image_with_nonzero_values():
    # Image contains nonzero values, but should be overwritten
    img = np.ones((4, 4, 3), dtype=np.uint8) * 222
    tile = np.ones((2, 2, 3), dtype=np.uint8) * 44
    codeflash_output = create_filled_image(img, [tile], (2, 2), seed=11); result = codeflash_output # 52.6μs -> 62.8μs (16.3% slower)

def test_edge_tile_pool_with_different_shapes_raises():
    # Tile pool contains tiles of different shapes; should raise error or behave unpredictably
    img = np.zeros((4, 4, 3), dtype=np.uint8)
    tile1 = np.ones((2, 2, 3), dtype=np.uint8)
    tile2 = np.ones((3, 2, 3), dtype=np.uint8)
    # Should work as long as cropping is correct, but if tile_size doesn't match, could fail
    # Here, we expect the function to crop as needed, so no error should be raised
    codeflash_output = create_filled_image(img, [tile1, tile2], (2, 2), seed=22); result = codeflash_output # 50.8μs -> 62.6μs (18.8% slower)

def test_edge_tile_size_zero_or_negative_raises():
    # Tile size is zero or negative; should raise ValueError
    img = np.zeros((4, 4, 3), dtype=np.uint8)
    tile = np.ones((2, 2, 3), dtype=np.uint8)
    with pytest.raises(ValueError):
        create_filled_image(img, [tile], (0, 2), seed=1)
    with pytest.raises(ValueError):
        create_filled_image(img, [tile], (2, -1), seed=1)

def test_edge_image_with_one_pixel():
    # Image is 1x1; tile is 2x2, should crop tile
    img = np.zeros((1, 1, 3), dtype=np.uint8)
    tile = np.ones((2, 2, 3), dtype=np.uint8) * 99
    codeflash_output = create_filled_image(img, [tile], (2, 2), seed=3); result = codeflash_output # 63.4μs -> 79.3μs (20.1% slower)

# -------------------- Large Scale Test Cases --------------------

def test_large_scale_many_tiles_and_large_image():
    # Large image and large tile pool
    img = np.zeros((100, 100, 3), dtype=np.uint8)
    tile_pool = [np.ones((10, 10, 3), dtype=np.uint8) * i for i in range(1, 11)]  # 10 tiles, values 1..10
    codeflash_output = create_filled_image(img, tile_pool, (10, 10), seed=100); result = codeflash_output # 250μs -> 163μs (53.6% faster)
    # Check that all values are from tile pool
    unique_vals = np.unique(result)

def test_large_scale_non_divisible_large_image():
    # Large image, tile size does not divide image size
    img = np.zeros((123, 98, 3), dtype=np.uint8)
    tile_pool = [np.ones((15, 15, 3), dtype=np.uint8) * 200, np.ones((15, 15, 3), dtype=np.uint8) * 150]
    codeflash_output = create_filled_image(img, tile_pool, (15, 15), seed=321); result = codeflash_output # 181μs -> 137μs (32.1% faster)
    # All values are from tile pool
    unique_vals = np.unique(result)

def test_large_scale_performance():
    # Test that function completes in reasonable time for large input
    img = np.zeros((500, 500, 3), dtype=np.uint8)
    tile_pool = [np.ones((50, 50, 3), dtype=np.uint8) * i for i in range(1, 21)]  # 20 tiles
    import time
    start = time.time()
    codeflash_output = create_filled_image(img, tile_pool, (50, 50), seed=555); result = codeflash_output # 345μs -> 256μs (34.8% faster)
    elapsed = time.time() - start

# -------------------- Edge Case: Invalid Inputs --------------------

def test_invalid_img_array_shape_raises():
    # img_array does not have 3 dimensions
    img = np.zeros((4, 4), dtype=np.uint8)  # Missing channel dimension
    tile = np.ones((2, 2, 3), dtype=np.uint8)
    with pytest.raises(ValueError):
        create_filled_image(img, [tile], (2, 2), seed=1) # 2.79μs -> 2.81μs (0.676% slower)


def test_invalid_seed_type_raises():
    # seed is not an int
    img = np.zeros((4, 4, 3), dtype=np.uint8)
    tile = np.ones((2, 2, 3), dtype=np.uint8)
    with pytest.raises(TypeError):
        create_filled_image(img, [tile], (2, 2), seed="not-an-int") # 12.8μs -> 12.8μs (0.400% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from invokeai.backend.image_util.infill_methods.tile import create_filled_image

To edit these changes git checkout codeflash/optimize-create_filled_image-mhoaffdx and push.