Help needed with par_iter() on a query.

[VitalyArtemiev]

Project link for context: https://github.dev/VitalyArtemiev/bevy-boids/blob/dfc4924a713bc12bb1c12469f8e01bea5ad1973b/src/boid.rs#L105

Good time of day to you. I seem to have run into a trait/borrowchecker problem that is beyond my understanding.
I have a function:

pub fn hard_collisions(mut q_boids: Query<(&Transform, &mut Velocity), With<Boid>>,
                       q_walls: Query<(&Obstacle, &Transform), With<HardCollision>>, tree: Res<NNTree>){
    /// Find wall. Find all ents near wall. Remove vel along normal.
    q_walls.par_iter().for_each(|(obstacle,transform)|{
        for (_other, entity) in tree.within_distance(transform.translation, 0.5) {

            if let Ok((_transform, mut velocity)) = q_boids.get_mut(entity.unwrap()) {
                let p_v = velocity.v.project_onto(obstacle.normal);
                velocity.v -= p_v;
                let a_v =  velocity.a.project_onto(obstacle.normal);
                velocity.a -= a_v;
            }
        }
    });
}

It throws the following error during compilation:

error[E0277]: the trait bound `&mut bevy::prelude::Query<'_, '_, (&bevy::prelude::Transform, &mut kinematics::Velocity), bevy::prelude::With<Boid>>: Clone` is not satisfied in `{closure@src\boid.rs:108:33: 108:55}`
    --> src\boid.rs:108:33
     |
 108 |       q_walls.par_iter().for_each(|(obstacle,transform)|{
     |                          -------- ^---------------------
     |                          |        |
     |  ________________________|________within this `{closure@src\boid.rs:108:33: 108:55}`
     | |                        |
     | |                        required by a bound introduced by this call
 109 | |         for (_other, Some(entity)) in tree.within_distance(transform.translation, 0.5) {
 110 | |
 111 | |             if let Ok((_transform, mut velocity)) = q_boids.get_mut(entity) {
 ...   |
 117 | |         }
 118 | |     });
     | |_____^ within `{closure@src\boid.rs:108:33: 108:55}`, the trait `Clone` is not implemented for `&mut bevy::prelude::Query<'_, '_, (&bevy::prelude::Transform, &mut kinematics::Velocity), bevy::prelude::With<Boid>>`, which is required by `{closure@src\boid.rs:108:33: 108:55}: Clone`
     |
     = note: `Clone` is implemented for `&bevy::prelude::Query<'_, '_, (&bevy::prelude::Transform, &mut kinematics::Velocity), bevy::prelude::With<Boid>>`, but not for `&mut bevy::prelude::Query<'_, '_, (&bevy::prelude::Transform, &mut kinematics::Velocity), bevy::prelude::With<Boid>>`
 note: required because it's used within this closure
    --> src\boid.rs:108:33
     |
 108 |     q_walls.par_iter().for_each(|(obstacle,transform)|{
     |                                 ^^^^^^^^^^^^^^^^^^^^^^
 note: required by a bound in `QueryParIter::<'w, 's, D, F>::for_each`
    --> C:\Users\vitaly\.cargo\registry\src\index.crates.io-6f17d22bba15001f\bevy_ecs-0.14.2\src\query\par_iter.rs:37:62
     |
 37  |     pub fn for_each<FN: Fn(QueryItem<'w, D>) + Send + Sync + Clone>(self, func: FN) {
     |                                                              ^^^^^ required by this bound in `QueryParIter::<'w, 's, D, F>::for_each`

It compiles if you replace par_iter() with just iter().

I'm not familiar with query internals nor am I fluent it Rust's type system, but I'm reasonably sure what I'm attempting to do should be possible. I'm guessing for parallel iteration to work, it needs to clone the query over to another thread, but cannot for some reason. Can someone point me in the right direction? I have a feeling there's a one-keyword or one-line fix for this, I just don't know where to look.

[SkiFire13]

Unfortunately what you're trying to do is impossible. Fundamentally, a mutable query can only be accessed in one place at a time. With par_iter however there will be multiple threads running the given closure, and they will all try to access the mutable query at the same time, which cannot be allowed.

[Tonaion02]

I'm having a similar problem that i am trying to solve or trying to find a workaround for that.

I have a data structures where i have saved the entities that i want to read in parallel . For constraint of the problem i am sure that entities are unique in this data structure. In that case i need to modify some components, so i must use a query object. Unfortunately same like you i can't share a mutable query through another parallel context.

But i am sure that i am not trying to access to the same entity from multiple threads, so i decided to try to wrap the data of a component in a mutex. With that i can modify the component's data with a non mutable query.

The only concern is about performance, but i am thinking that probably, if i am sure that entities are unique, there isn't a thread that is waiting for a lock, each mutex is locked and unlocked exactly one time.

I don't know if can fit your problem, and i don't know what is the performance in this case.