Task in task pools panics randomly

[IGOLTA]

I am writing a chunk loading system. I want to generate chunks procedurally which can take time and must be done asynchronously. For this purpose I need AsyncTaskPools. But when using theses they randomly panic if I poll them to check if they are finished. I do nothing in the Chunk creation function except pausing the thread for test purposes. I followed the example https://github.com/bevyengine/bevy/blob/main/examples/async_tasks/async_compute.rs to write my code.

The panic I get:

thread 'Compute Task Pool (1)' panicked at /home/Louis/.cargo/registry/src/index.crates.io-6f17d22bba15001f/async-task-4.7.0/src/task.rs:452:45:
task has failed
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Encountered a panic in system `voxel_dream::voxel_world::chunk_generator::chunk_generation_system_end_generation`!
Encountered a panic in system `bevy_app::main_schedule::Main::run_main`!

Here is the ChunkGeneratorPlugin:

pub mod world_generator;

use bevy::tasks::futures_lite::future;
use bevy::tasks::{block_on, AsyncComputeTaskPool, Task};
use bevy::{math::I64Vec3, utils::HashSet};
use bevy::prelude::*;
use noise::Perlin;

use self::world_generator::WorldGenerator;

use super::chunk::Chunk;

#[derive(Component, PartialEq, Eq, Clone, Copy)]
pub enum ChunkLoadingStatus {
    GenerationRequested(I64Vec3),
    Loaded,
    DestructionRequested,
}

#[derive(Component)]
pub struct ChunkGenerationTask(Task<Chunk>);

pub struct ChunkGeneratorPlugin;

impl Plugin for ChunkGeneratorPlugin {
    fn build(&self, app: &mut App) {
        app
            .insert_resource(WorldGenerator{
                perlin: Perlin::new(65464),
                amplitude: 5.,
                scale: 10.,
            })
            .add_systems(Update, (
                chunk_generator_system,
                chunk_generation_system_end_generation,
                chunk_generation_system_start_generation,
                chunk_destroying_system
            ))
        ;
    }
}


#[derive(Component, Debug)]
pub struct ChunkGenerator {
    pub render_distance: u32
}

fn chunk_generator_system(
    mut commands: Commands,
    mut chunks_query: Query<(Entity, &Chunk, & mut ChunkLoadingStatus)>,
    generator_query: Query<(&ChunkGenerator, &Transform)>,
) {
    //Spawns entities with the ChunkLoadingStatus::GenerationRequested component
}


fn chunk_generation_system_start_generation (
    mut commands: Commands,
    mut in_generation_chunks_query: Query<(Entity, &mut ChunkLoadingStatus, &mut ChunkGenerationTask)>,
    mut generation_requested_chunks_query: Query<(Entity, &ChunkLoadingStatus), Without<ChunkGenerationTask>>,
    world_generator: Res<WorldGenerator>
) {
    //Creates a generation task if requested
    let thread_pool = AsyncComputeTaskPool::get();

    for (entity, status) in generation_requested_chunks_query.iter() {
        if let ChunkLoadingStatus::GenerationRequested(pos) = *status {
            let generator = world_generator.clone();
            let task: Task<Chunk> = thread_pool.spawn(async move {Chunk::generate_at_pos(pos, generator).await});
            commands.entity(entity).insert(ChunkGenerationTask(task));
        }
    }
}

fn chunk_generation_system_end_generation (
    mut commands: Commands,
    mut in_generation_chunks_query: Query<(Entity, &mut ChunkLoadingStatus, &mut ChunkGenerationTask)>,
) {
    for (entity, mut status, mut task) in in_generation_chunks_query.iter_mut() {
        if let Some(chunk) = block_on(future::poll_once(&mut task.0)) { //<- Does not panic if I remove this if statement
             //Status update (commented)
             //*status = ChunkLoadingStatus::Loaded;
             //commands.entity(entity).insert(chunk);
        }
    }
}


fn chunk_destroying_system(
    mut commands: Commands,
    chunks_query: Query<(Entity, &ChunkLoadingStatus), With<Chunk>>,
) {
    for (entity, status) in chunks_query.iter() {
        if status == &ChunkLoadingStatus::DestructionRequested {
            commands.entity(entity).despawn_recursive();
        }
    }
}

Content of chunk generate at pos:

    pub async fn generate_at_pos(position: I64Vec3, world_generator: WorldGenerator) -> Self {
        Self { 
            octree: Octree::new(CHUNK_OCTREE_SIZE, None), 
            position
        }
    }

[SkiFire13]

The problem is that you never remove the ChunkGenerationTask component, so you end up polling the Task contained in it again after it has already yielded a value, which results in that panic you saw. The panic message from async-task is definitely not user friendly though.

[IGOLTA]

Thank you for solving my issue this quick. Indeed the panic message is kind of obscure.