Bug: memory leak after force unwind

[zonyitoo]

This bug exists because in coroutine_entry, we cannot know whether the callback() is panicked. So we will continue the execution and set the state to State::Finished and yield back, which will cause memory leak, because the coroutine_exit is not called!!

[zonyitoo]

cc @lhecker Please review.

[zonyitoo]

Test snippet:

extern crate coio;

use coio::Scheduler;

fn main() {
    Scheduler::new()
        .run(|| {
            loop {
                let hdl = Scheduler::spawn(|| {
                    Scheduler::sched();

                    let _x = 1;
                    panic!("Just panic!");
                });

                assert!(hdl.join().is_err());
            }
        })
        .unwrap();
}

This process will not allocate memory continuously.

BTW: cc @lhecker , if you run this code with .with_worker(??), you will see a crash thread panicked while panicking. Stack trace shows that it crashes in Scheduler::park_processor's .unwrap(), which indicates that the self.idle_processor_mutex is poisoned. But

• If you run the Scheduler with 1 thread, it won't crash at all.
• If you remove the Scheduler::sched(), it won't crash at all.

I think it is because when the panic::catch_unwind is called, it will register to the current thread's local storage. So if you call Scheduler::sched(), this Coroutine may be stolen by the other thread .. so if this Coroutine panicked on the other Processor, it will still triggered the original thread's panic handler, which is the reason that it reports thread panicked while panicking.

These worth to open a new issue to solve this, and I have an idea. Nope. I don't have.