Low FPS even in release

[erayerdin]

I'm trying to make a grid-based game. Here is the Startup initialization system:

pub(crate) fn grid_init_system(game_config: Res<GameConfig>, par_commands: ParallelCommands) {
    debug!("Initializing grids...");
    const TOTAL_GRID_LENGTH: u16 = u8::MAX as u16 * u8::MAX as u16;
    let mut grid_spawners: Vec<(Grid, Stroke)> = Vec::with_capacity(TOTAL_GRID_LENGTH as usize);

    for x in 0..u8::MAX {
        for y in 0..u8::MAX {
            let grid = Grid::new(x, y);
            let spawner: (Grid, Stroke) = (grid, Stroke::new(Color::WHITE, 1.0));
            grid_spawners.push(spawner);
        }
    }

    grid_spawners.par_iter().for_each(|(grid, stroke)| {
        par_commands.command_scope(|mut commands| {
            let shape = shapes::Rectangle {
                extents: Vec2 {
                    x: GRID_SIZE as f32,
                    y: GRID_SIZE as f32,
                },
                ..default()
            };
            let (pos_x, pos_y) = grid.positions();

            commands.spawn((
                *grid,
                ShapeBundle {
                    path: GeometryBuilder::build_as(&shape),
                    spatial: SpatialBundle {
                        transform: Transform::from_xyz(pos_x, pos_y, 0.0),
                        visibility: game_config.grid_visibility(),
                        ..default()
                    },
                    ..default()
                },
                *stroke,
            ));
        });
    });
}

Here is the Update paint system:

pub(crate) fn grid_paint_system(
    mut visibility_query: Query<&mut Visibility, With<Grid>>,
    game_config: Res<GameConfig>,
) {
    debug!("Painting grids...");

    // REF: https://github.com/bevyengine/bevy/blob/64b987921c4a4d54c3f250ae63bb9eb6b44a02aa/examples/ecs/parallel_query.rs#L31
    visibility_query.par_iter_mut().for_each(|mut visibility| {
        *visibility = game_config.grid_visibility();
    });
}

GameConfig is a resource to show the grids or not:

#[derive(Debug, Default, Resource, Reflect, InspectorOptions)]
#[reflect(Resource, InspectorOptions)]
pub(crate) struct GameConfig {
    grid_visibility: Visibility,
}

impl GameConfig {
    pub(crate) fn grid_visibility(&self) -> Visibility {
        self.grid_visibility
    }
}

pub(crate) fn has_game_config_changed(game_config: Res<GameConfig>) -> bool {
    game_config.is_changed()
}

And GridPlugin is configured as such:

pub(super) struct GridPlugin;

impl Plugin for GridPlugin {
    fn build(&self, app: &mut bevy::prelude::App) {
        debug!("Initializing GridPlugin...");
        app.add_systems(Startup, grid_init_system)
            .add_systems(Update, grid_paint_system.run_if(has_game_config_changed));
    }
}

This runs in low FPS, even in the release mode. In fact, I've tried many of these methods shown below to run the game:

cargo run --features "bevy/dynamic_linking"
cargo run --features "bevy/dynamic_linking" --release
WGPU_BACKEND=gl cargo run --features "bevy/dynamic_linking"
WGPU_BACKEND=gl cargo run --features "bevy/dynamic_linking" --release

Nothing really helped. Running `cargo run --features "bevy/dynamic_linking" starts with these logs:

2024-04-26T13:50:00.590276Z  INFO bevy_winit::system: Creating new window "App" (0v1)
2024-04-26T13:50:00.590501Z  INFO log: Guessed window scale factor: 1.0833333333333333    
2024-04-26T13:50:00.618546Z  WARN log: InstanceFlags::VALIDATION requested, but unable to find layer: VK_LAYER_KHRONOS_validation    
2024-04-26T13:50:00.663196Z  INFO bevy_render::renderer: AdapterInfo { name: "llvmpipe (LLVM 17.0.6, 256 bits)", vendor: 65541, device: 0, device_type: Cpu, driver: "llvmpipe", driver_info: "Mesa 23.3.6 (LLVM 17.0.6)", backend: Vulkan }
2024-04-26T13:50:00.820835Z  INFO log: Gamepad /dev/input/event8 ( USB Gamepad          ) connected.    
2024-04-26T13:50:00.822083Z DEBUG oxidized_pixel_dungeon::grid: Initializing GridPlugin...
2024-04-26T13:50:00.855554Z DEBUG oxidized_pixel_dungeon::core: Running CorePlugin::init_system
2024-04-26T13:50:00.855551Z DEBUG oxidized_pixel_dungeon::grid::systems: Initializing grids...
2024-04-26T13:50:00.921002Z  INFO bevy_input::gamepad: Gamepad { id: 0 } Connected
2024-04-26T13:50:00.923629Z DEBUG oxidized_pixel_dungeon::grid::systems::paint: Painting grids...

In case you need to see the Cargo.toml, here it is:

[package]
name = "oxidized-pixel-dungeon"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
bevy = "0.13.2"
bevy-inspector-egui = "0.24.0"
bevy_prototype_lyon = "0.11.0"
rayon = "1.10.0"

# Enable a small amount of optimization in debug mode
[profile.dev]
opt-level = 1

# Enable high optimizations for dependencies (incl. Bevy), but not for our code:
[profile.dev.package."*"]
opt-level = 3

I've found out the FPS is lower because when I hover over the debug toolbar (egui), it almost takes a second to respond. Would like to know what would be the cause. Is it how I designed it?

Thanks in advance.

---

Update 1

Yes, there's an overuse of parallelism here, and that's mainly because I wanted to fix the performance by making it parallel. Removing it does not really help as replied in #13108 (comment).

Also another note: Setting the visibility of grids to Invisible actually aids the performance.

Update 2

There's another thing: Maybe this is related to Nilirad/bevy_prototype_lyon#159.

Update 3

I've opened up an issue here: Nilirad/bevy_prototype_lyon#246.

[jdm]

Out of curiosity, does removing the parallelism affect the performance at all?

[erayerdin]

Well, actually, the overuse of parallelism is because the performance was overall terrible. Tried to fix it with it but let me revert back and see the result again.

[erayerdin]

Nope, removing the parallelism does not make any impact at all. Overall, the changes I've done to remove it and test it are these:

pub(crate) fn grid_init_system(
    game_config: Res<GameConfig>,
    par_commands: ParallelCommands,
    mut commands: Commands,
) {
    debug!("Initializing grids...");
    // const TOTAL_GRID_LENGTH: u16 = u8::MAX as u16 * u8::MAX as u16;
    // let mut grid_spawners: Vec<(Grid, Stroke)> = Vec::with_capacity(TOTAL_GRID_LENGTH as usize);

    // for x in 0..u8::MAX {
    //     for y in 0..u8::MAX {
    //         let grid = Grid::new(x, y);
    //         let spawner: (Grid, Stroke) = (grid, Stroke::new(Color::WHITE, 1.0));
    //         grid_spawners.push(spawner);
    //     }
    // }

    // grid_spawners.par_iter().for_each(|(grid, stroke)| {
    //     par_commands.command_scope(|mut commands| {
    //         let shape = shapes::Rectangle {
    //             extents: Vec2 {
    //                 x: GRID_SIZE as f32,
    //                 y: GRID_SIZE as f32,
    //             },
    //             ..default()
    //         };
    //         let (pos_x, pos_y) = grid.positions();

    //         commands.spawn((
    //             *grid,
    //             ShapeBundle {
    //                 path: GeometryBuilder::build_as(&shape),
    //                 spatial: SpatialBundle {
    //                     transform: Transform::from_xyz(pos_x, pos_y, 0.0),
    //                     visibility: game_config.grid_visibility(),
    //                     ..default()
    //                 },
    //                 ..default()
    //             },
    //             *stroke,
    //         ));
    //     });
    // });

    for x in 0..u8::MAX {
        for y in 0..u8::MAX {
            let grid = Grid::new(x, y);

            let shape = shapes::Rectangle {
                extents: Vec2 {
                    x: GRID_SIZE as f32,
                    y: GRID_SIZE as f32,
                },
                ..default()
            };
            let (pos_x, pos_y) = grid.positions();

            commands.spawn((
                grid,
                ShapeBundle {
                    path: GeometryBuilder::build_as(&shape),
                    spatial: SpatialBundle {
                        transform: Transform::from_xyz(pos_x, pos_y, 0.0),
                        visibility: game_config.grid_visibility(),
                        ..default()
                    },
                    ..default()
                },
                Stroke::new(Color::WHITE, 1.0),
            ));
        }
    }
}

pub(crate) fn grid_paint_system(
    mut visibility_query: Query<&mut Visibility, With<Grid>>,
    game_config: Res<GameConfig>,
) {
    debug!("Painting grids...");

    // REF: https://github.com/bevyengine/bevy/blob/64b987921c4a4d54c3f250ae63bb9eb6b44a02aa/examples/ecs/parallel_query.rs#L31
    // visibility_query.par_iter_mut().for_each(|mut visibility| {
    //     *visibility = game_config.grid_visibility();
    // });

    visibility_query.iter_mut().for_each(|mut visibility| {
        *visibility = game_config.grid_visibility();
    });
}

[GitGhillie]

Looks like you GPU might not be getting detected? In your adapter info:
AdapterInfo { name: "llvmpipe (LLVM 17.0.6, 256 bits)", vendor: 65541, device: 0, device_type: Cpu, driver: "llvmpipe", driver_info: "Mesa 23.3.6 (LLVM 17.0.6)", backend: Vulkan }
It says device_type: Cpu. Not sure how to fix it but maybe you can try one of the WGPU examples to see if it's a Bevy issue or WGPU issue.

[erayerdin]

Or maybe related to this: #13113

Strangely, as in the original post, running WGPU_BACKEND=gl cargo run --features "bevy/dynamic_linking" (even with --release flag) chooses GPU correctly as seen below:

2024-04-28T05:06:53.568488Z  INFO bevy_render::renderer: AdapterInfo { name: "OLAND (radeonsi, , LLVM 17.0.6, DRM 2.50, 6.8.7-200.fc39.x86_64)", vendor: 4098, device: 0, device_type: Other, driver: "", driver_info: "", backend: Gl }

Even though it uses GPU, it still suffers from the FPS drop. The video below is recorded with release build.

Peek.2024-04-28.08-09.mp4

Addendum: It consistently uses 30% of my CPU and 700 mB of RAM.

[ptinc89]

I don't know the exact requirements of your game, but I don't think you need to query and modify the visibility of all 255^2 grids every frame. Bevy has excellent change detection filters like Changed<SomeComponent>, which lets you skip unnecessary work by acting only when relevant data has actually changed. Therefore, using a resource such as GameConfig to manage entire grids might not align well with Bevy's ECS paradigm.

[ptinc89]

P.S. If you are hesitant to modify existing systems, I recommend adding a return statement like this:

pub(crate) fn grid_paint_system(
    mut visibility_query: Query<&mut Visibility, With<Grid>>,
    game_config: Res<GameConfig>,
) {
    if !game_config.is_changed() { return; }
    
    debug!("Painting grids...");

    visibility_query.iter_mut().for_each(|mut visibility| {
        *visibility = game_config.grid_visibility();
    });
}

[erayerdin]

Yep, I've been reading unofficial Bevy cheatsheet and get a better understanding each day. I've taken the approach of attaching a Grid component to entities individually. The only caveat is I cannot draw borders to the grids but that's fine. Bevy Inspector helps me anyway. Thanks for your time. :)

[jdnewman85]

None of the logs you've shown have an official GPU driver used. Mesa and radeonsi are software renderers and so would cause high CPU usage.