I'm wondering what the best way to do this in Rust is. I have a disk controller that I send commands to and the controller signals an interrupt when its sent back a response. I'd like my function to be callable, but not fully return, until its received some kind of response via an interrupt. Right now I do this through a stack-allocated queue of
bools, and I loope endlessly on it until I'm able to dequeue something, and halt the processor while I wait. But I doubt that this is the "right" way to do it. I've got a task executor and async/await works, but I find that, if I call an async function but I don't await it, it never executes. So what's the right way to do this? What am I missing?
To implement something like this with async/await, you would need to implement some mechanism for a wakeup to be sent to the runtime when the interrupt arrives.
That's right, all that calling an
async fn does it create a
Future representing an execution of that function, it does not actually run any of the code in the function.
You have to either
.await the returned future, or call
Future::poll on the future in order to have it actually execute. If you cannot just
.await in your code, your runtime might have something like a
spawn function that will do this for you (running the future as a new task in the background). You could also try to use the combinators from the
futures-intrusive crate, which allow selecting on multiple futures or combining their results in other ways.