fixed_timestep tutorial for 0.10

[physics515]

Hello All,

I'm writing my first bevy app and have a bit of an unusual use-case, I'm not writing a game but an ECS is the perfect fit for the data I need to store and execute on, so I thought I'd give bevy a shot. The problem is that I don't need the raw performance of an infinite loop running full blast to process what amounts to spreadsheet calculations. I see talk of using fixed_timestep to limit the tick rate all over the internet but every time I try to implement it, it fails. I come to the conclusion that most of the tutorials that are online are for bevy 0.9 and below and that bevy had some major updates to scheduling in 0.10.

Here is my code:

pub fn app_setup(channels: Channels) -> App {
    let mut app = App::new();
    app.insert_resource(ShouldSaveResource(false));
    app.add_systems((save.run_if(should_save), load, add_scripts, add_variables, remove_scripts).chain());
    app.add_system(run_scripts);
    app
}

I would like the entire loop to run once or twice a second. Any point in the right direction would be appreciated.

Thank you,

[wilk10]

The easiest solution would be to have a repeating Timer in a resource and inside your systems check if the timer has finished, and if it hasn't return early.

For example the apply_deferred example uses a timer like this.

You'll need a separate system that runs every frame that ticks the timer, but that's a very cheap operation.

[tim-blackbird]

The examples in the repository on the latest branch will always be up to date with the latest released version of Bevy.
The example for fixed timestep is here.

[physics515]

Beautiful. I've been looking at the main branch wondering why everything is woefully out of date. I'll give this a shot and report back.

[physics515]

Worked like a charm. Though it still seems to be using 15%-30% CPU usage. Any ideas why that is?

[rlidwka]

The problem is that I don't need the raw performance of an infinite loop running full blast to process what amounts to spreadsheet calculations.

Fixed timestep is NOT used to limit tickrate of your bevy application. It is used to stabilize tickrate of a specific systems within your bevy application.

If you want to limit tickrate of bevy app, first check bevy::window::PresentMode (setting it to VSync would limit tickrate to your display frequency), and use bevy_framepace plugin or similar to lower it further.

But if you are using bevy to make UI application, you can configure it to only run whenever user interacts with it. Please check out this example, I believe that's what you are looking for:
https://github.com/bevyengine/bevy/blob/main/examples/window/low_power.rs

[physics515]

Thank you, this looks intriguing, I'll look it over. However, I'm not using bevy to render anything. I am using it as a server back-end (I know this is nowhere close to the intended use) but the application is very game-like in that there are lots of events that are state dependent.

You can quite literally think of what I'm building as a spreadsheet where the evaluation of a formula in one cell may trigger the evaluation of countless other cells. I attempted to roll my own ECS but when the logic got more complex I thought "let's see what the big guys in the rust ECS ring can offer?"

So far, it has been working great, I just would like to limit CPU usage or even suspend the app when nothing is happening.

[rlidwka]

Oh okay in that case you won't have GUI window at all I suppose?

Disregard everything I said above. You need custom runner:

use std::time::Duration;
use bevy::prelude::*;
use bevy::log::LogPlugin;
use bevy::utils::Instant;

fn main() {
    App::new()
        .add_plugins(MinimalPlugins)
        .add_plugin(LogPlugin::default())
        .set_runner(custom_runner)
        .add_system(|| bevy::log::info!("hello"))
        .run();
}

fn custom_runner(mut app: App) {
    let time_between_frames = Duration::from_secs_f32(1.);

    loop {
        let last_frame_start = Instant::now();
        app.update();

        let exec_time = Instant::now().duration_since(last_frame_start);
        if exec_time < time_between_frames {
            std::thread::sleep(time_between_frames - exec_time);
        }
    }
}

You can control it's frequency exactly as you want, or even stop loops if no clients are connected.

[rlidwka]

Or you can write your own server, keep App somewhere, and call App::update() on it when you need to refresh your calculations.

[physics515]

Oh okay in that case you won't have GUI window at all I suppose?

Disregard everything I said above. You need custom runner:

This looks very promising! I will give it a go in the morning. I tried Framepace and you are correct, it complains that I don't have a RenderApp, and when I add one of those, it complains that I'm not running on the main thread and I don't know how to fix that since I can't run on the main thread.

Using a custom runner might be nice because I am already loading requests from the Axum server into queues. I can just watch the queues and if there are no requests then I don't have to run. Brilliant!