Add resource_scope variant for nonsend resources

[jakobhellermann]

What problem does this solve or what need does it fill?

Bevy has a resource_scope method which lets you have mutable access to a resource and the world at the same time by temporarily removing the resource:

world.resource_scope(|world, mut a: Mut<A>| {
    let b = world.get_mut::<B>(entity).unwrap();
    a.0 += b.0;
});

Is is roughly equivalent to

let a = world.remove_resource::<A>();
f(world, b);
world.insert_resource(a);

Bevy also has the concept of non-send resources; resources which do not implement the Send auto trait (and Sync?) so any systems that access them are only scheduled on the main thread. This is useful for example for some scripting language runtimes or OS operations that can only run on one thread.

There is, however, no variant of resource_scope which works for nonsend resources.

What solution would you like?

Add a non_send_resource_scope function, which is pretty much a copy of resource_scope (

bevy/crates/bevy_ecs/src/world/mod.rs

Line 1087 in bc863ce

pub fn resource_scope<R: Resource, U>(&mut self, f: impl FnOnce(&mut World, Mut<R>) -> U) -> U {

) but relaxes the R: Resource bound to R: 'static.
The method also needs to validate that it is being run on the main thread, #6037 (comment).

What alternative(s) have you considered?

Write

let runtime = world.remove_non_send_resource::<JsRuntime>().unwrap();
f(runtime, world);
world.insert_non_send_resource(runtime);

instead. Less ergonomic and a tiny bit less performant.

[DJMcNab]

In theory, resource_scope should just work for NonSend resources - there's no part of that API which requires the type be Send - if you have an &mut World, you're already on the main thread (at least in theory, in practise that's not necessarily true, but we have enough information to panic in those cases).

[jakobhellermann]

Hm, right. In that case it should be enough to just remove the R: Resource bound which implies Send + Sync and leave a comment explaining how this is safe without the bound.

[jakobhellermann]

        let mut world = World::default();
        world.insert_non_send_resource(A(0));

        std::thread::scope(|_| {
            world.resource_scope(|world: &mut World, mut value: Mut<A>| {
                value.0 += 1;
                assert!(!world.contains_resource::<A>());
            });
            assert_eq!(world.get_non_send_resource::<A>().unwrap().0, 1);
        });

would have to be disallowed, right?
So resource_scope also needs a call to self.validate_non_send_access::<R>();.
But it should be allowed to call resource_scope on another thread for a regular resource.
We can't specialize on R: Send, so is

but we have enough information to panic in those cases)

true?

[DJMcNab]

We store whether a resource is registered as non_send though? So we read that field to validate?

[jakobhellermann]

Ah yes, forgot about that field.
So we need to add

        let component_info = self.components().get_info(component_id).unwrap();
        if !component_info.is_send_and_sync() {
            self.validate_non_send_access::<R>();
        }

[Pietrek14]

I would like to try it, since noone is assigned.