cold futures: speaker note

[robamu]

In the embedded contexts, we can have futures that already start part of the work (e.g. UART transmission futures which loads the FIFO with the initial bytes). So those are not really "cold", or at the very least I think calling them "cold" is confusing.

Maybe we can just remove this? I think the knowledge that futures need to be executed/resolved is sufficient.

[cloudflare-workers-and-pages]

Deploying ferrous-systems-rust-training with    Cloudflare Pages

Latest commit:	37f9357
Status:	✅  Deploy successful!
Preview URL:	https://0c69eb7f.ferrous-systems-rust-training.pages.dev
Branch Preview URL:	https://futures-might-not-be-cold.ferrous-systems-rust-training.pages.dev

View logs

[robamu]

replaced by speaker note to clarify that some work might already start during the future construction

[listochkin]

If the future is creates using async then you can't do any custom work in the constructor.

If you make a future manually (using implementation Future for StructType or poll_fn), then you can customize the behavior.

[jonathanpallant]

I think this was a nod towards:

fn do_process() -> impl Future<Foo> {
    hal::start_dma();
    async {
        hal::wait_dma().await
    }
}

Where a sync function both does some work, and returns a future that must be polled. I don't know how often this comes up in practice.

[jonathanpallant]

See also

rust-training/example-code/qemu-common/src/cmsdk_uart/asynch.rs

Lines 196 to 253 in f063b58

	impl<'uart> Transmission<'uart> {
	/// Create a new asynchronous future for a write/transmit operation.
	///
	/// Will send the given buffer under interrupt, producing
	/// `core::task::Poll::Ready` once complete.
	///
	/// Do not pass a zero-length slice - this will panic.
	///
	/// We can only keep this object whilst *both* the Async TX UART *and* the buffer are alive.
	fn new(tx_async: &'uart mut AsyncTx, data: &'uart [u8]) -> Self {
	defmt::debug!(
	"Creating Transmission(data=0x{=usize:08x}, len={})",
	data.as_ptr() as usize,
	data.len(),
	);
	assert!(!data.is_empty());
	// tx.inner.disable_interrupts();
	tx_async.uart_state.tx_length.store(data.len(), Relaxed);
	tx_async.uart_state.tx_transmitted.store(1, Relaxed);
	tx_async
	.uart_state
	.tx_buffer
	.store(data.as_ptr() as *mut u8, Release);
	// It is actually important to write AFTER the UART was enabled.
	defmt::debug!("TX 0x{:02x}", data[0]);
	tx_async.basic_tx.write(data[0]).unwrap();
	Self { tx: tx_async }
	}
	}
	impl core::future::Future for Transmission<'_> {
	type Output = ();
	fn poll(
	self: core::pin::Pin<&mut Self>,
	cx: &mut core::task::Context<'_>,
	) -> core::task::Poll<Self::Output> {
	defmt::debug!("Polling Transmission complete...");
	self.tx.uart_state.waker.register(cx.waker());
	if self.tx.uart_state.tx_buffer.load(Acquire).is_null() {
	defmt::debug!("Ready!");
	core::task::Poll::Ready(())
	} else {
	defmt::debug!("Pending...");
	core::task::Poll::Pending
	}
	}
	}
	impl Drop for Transmission<'_> {
	fn drop(&mut self) {
	if !self.tx.uart_state.tx_buffer.load(Acquire).is_null() {
	self.tx.basic_tx.clear_interrupts();
	self.tx.basic_tx.enable_interrupt(false);
	}
	}
	}

, where we impl Future for CustomType to get Drop behaviour for the Future.