Memory Leak When Loading Scenes

[LordRatte]

Bevy version

bevy = "0.13.0"

[Optional] Relevant system information

• cargo 1.78.0-nightly (7065f0ef4 2024-03-12)
• MacOS 14.4 (23E214)
• Apple M1 CPU
• AdapterInfo { name: "Apple M1", vendor: 0, device: 0, device_type: IntegratedGpu, driver: "", driver_info: "", backend: Metal }
• Also tested on Wasm in Firefox with the same result.

What you did

I have been having a problem with a memory leak in my app. Here is a minimal example that reproduces the bug.

use bevy::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .insert_resource(Objects::default())
        .add_systems(Startup, setup)
        .add_systems(Update, update)
        .run();
}

#[derive(Resource, Default)]
struct Objects {
    mesh: Handle<Mesh>,
    material: Handle<StandardMaterial>,
    scene: Handle<Scene>,
}

#[derive(Component)]
struct Piece;

fn setup(
    mut commands: Commands,
    mut objects: ResMut<Objects>,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    asset_server: Res<AssetServer>,
) {
    commands.spawn(Camera3dBundle {
        transform: Transform::from_xyz(7., 15., -9.5).looking_at(Vec3::ZERO, Vec3::Y),
        camera: Camera {
            clear_color: ClearColorConfig::Custom(Color::rgb(0., 0.7, 0.89)),
            ..default()
        },
        ..default()
    });

    objects.mesh = meshes.add(Cuboid::new(1.0, 1.0, 1.0));
    objects.material = materials.add(Color::rgb_u8(124, 144, 255));
    objects.scene = asset_server.load(format!("tree_1.glb#Scene0"));
}

fn update(mut commands: Commands, objects: Res<Objects>, delete_query: Query<Entity, With<Piece>>) {
    for entity in delete_query.iter() {
        commands.entity(entity).despawn_recursive();
    }

    for i in 1..1000 {
        commands
            .spawn(PbrBundle {
                mesh: objects.mesh.clone(),
                material: objects.material.clone(),
                transform: Transform::from_xyz(0.0, 0.0, i as f32),
                ..default()
            })
            .insert(Piece);

        // The previous expression doesn't seem to have an effect
        // but the memory steadily increases when the following expression is included.
        commands
            .spawn(SceneBundle {
                scene: objects.scene.clone(),
                transform: Transform::from_xyz(0.0, 1., i as f32).with_scale(Vec3::splat(0.05)),
                ..Default::default()
            })
            .insert(Piece);
    }
}

In other words, entities are cleared and then added again, repeatedly. The problem still happens if there is some time between runs (e.g. once every second) but it just happens a bit slower.

What went wrong

The app memory usage steadily increases.

Additional information

It may be that some part of the loaded scene is not being properly deleted. I am not sure.

Potentially related to #9035 but it seems to not be an exclusively MacOS issue, given that I tried it on Wasm as well.

[james7132]

Does the issue still occur if you're running headless without a renderer? The other mentioned issue seems to be related to rendering on MacOS.

[LordRatte]

Does the issue still occur if you're running headless without a renderer? The other mentioned issue seems to be related to rendering on MacOS.

I will test it out. How do I run it headless?

I encountered the same issue on Windows 11 with bevy version "0.13.1", which seems to be related to the SceneSpawner resource. I attempted to estimate the memory usage of SceneSpawner and found that its memory consumption continuously increased. When the program's memory usage reached 500MB, SceneSpawner accounted for more than 220MB of it. The following code can be used to reproduce this issue:

use bevy::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .insert_resource(Objects::default())
        .add_systems(Startup, setup)
        .add_systems(Update, update)
        .run();
}

#[derive(Resource, Default)]
struct Objects {
    scene: Handle<Scene>,
}

#[derive(Component)]
struct Piece;

fn setup(mut objects: ResMut<Objects>, asset_server: Res<AssetServer>) {
    objects.scene = asset_server.add(Scene::new(World::new()));
}

fn update(mut commands: Commands, objects: Res<Objects>, delete_query: Query<Entity, With<Piece>>) {
    for entity in delete_query.iter() {
        commands.entity(entity).despawn_recursive();
    }

    for _ in 0..1000 {
        commands.spawn((
            objects.scene.clone(),
            Piece,
        ));
    }
}

[LordRatte]

I can confirm that this snippet has the same result.

[Brezak]

The memory leak stems from the spawned_instances field of the SceneSpawner never getting cleaned up.

[Brezak]

A full write-up of what's happening.

• When a new scene handle is added to an entity the scene_spawner system schedules the spawning of the scene with the SceneSpawner resource.
• As a result an InstanceId is created and is pushed along with the necessary data into scenes_to_spawn and scenes_with_parent
• Next the scene_spawner_system checks scenes_with_parent for despawned parent entities and marks down them down. Since our scene parent hasn't been despawned yet, this doesn't yet concern us.
• Instead we move on to spawning all the scene in scenes_to_spawn.
• Since our scene is not a dynamic scene, it will eventually be spawned with spawn_sync_internal. Importantly for us and our leak a InstanceInfo is created and pushed into spawned_instances.
• Moving on to the next time scene_spawner_system is triggered. Our code has decided to despawn our scene and the system is about to notice and write it down.
• Problematically dead_instances is only used to check if the scenes we're about to spawn still exist and nothing else.

So leak found. Just add something like

dead_instances.into_iter().for_each(|id| scene_spawner.despawn_instance(id));

to scene_spawner_system and et voila leak fixed, right? No, you see I lied to you when I said the scene_spawner_system would notice our scene parent pair has despawned. The pair is not in scenes_with_parent anymore. Why? Let's go back in time to the first time scene_spawner_system ran and spawned our scene.

• Our scene has been spawned and we're about to run set_scene_instance_parent_sync which is what breaks our original fix.
• You see set_scene_instance_parent_sync will mem::take the scenes_with_parent vec leaving it empty.
• So the next time scene_spawner_system runs scenes_with_parent won't contain our now despawned scene, its InstanceId won't be logged in dead_instances and our original fix won't remove anything.

As things stand, the fix is unlikely to be trivial, requiring a good understanding of how scene data is passed around the SceneSpawner. This write-up took a while and it's getting pretty late here so if anybody wants to take a stab at it I wish you good luck.

[LordRatte]

Do we know when the bug was introduced?