pub fn run_until_stalled(&mut self) {
        run_executor(|cx| match self.poll_pool(cx) {
            // The pool is empty.
            Poll::Ready(()) => Poll::Ready(()),
            Poll::Pending => {
                if woken() {
                    Poll::Pending
                } else {
                    // We're stalled for now.
                    Poll::Ready(())
                }
            }
        });
    }
Runs all tasks in the pool and returns if no more progress can be made
on any task.

```
use futures::executor::LocalPool;
use futures::task::LocalSpawnExt;
use futures::future::{ready, pending};

let mut pool = LocalPool::new();
let spawner = pool.spawner();

spawner.spawn_local(ready(())).unwrap();
spawner.spawn_local(ready(())).unwrap();
spawner.spawn_local(pending()).unwrap();

// Runs the two ready task and returns.
// The empty task remains in the pool.
pool.run_until_stalled();
```

This function will not block the calling thread and will return the moment
that there are no tasks left for which progress can be made;
remaining incomplete tasks in the pool can continue with further use of one
of the pool's run or poll methods. While the function is running, all tasks
in the pool will try to make progress.
futures-executor/src/local_pool.rs