add queue example

[Vollbrecht]

No description provided.

[okhsunrog]

Looks very useful, why not merged yet?

[ivmarkov]

Because I'm not sure it is ready and I was not called as a reviewer. @Vollbrecht - is this ready, and should I review?

[Vollbrecht]

yeah it was not high prio for me just wanted to put it out there before i forgot it.

The current queue API is not optimal but working, and i was thinking about ways to make it more ergonomically and require less unsafe. So till we have something better i just put it out here.

[ivmarkov]

yeah it was not high prio for me just wanted to put it out there before i forgot it.

The current queue API is not optimal but working, and i was thinking about ways to make it more ergonomically and require less unsafe. So till we have something better i just put it out here.

new_borrowed is ... weird and probably not necessary given that you can always borrow with just & and then unsafely move a copy of the borrowed reference into the ISR - either as a regular reference (with a possibly transmuted lifetime) or as a raw pointer.

So this API we should probably remove as I don't see the point of it at all.

Other than that, you can Arc the Queue and as long as the last reference to the queue is not in the ISR (which would still work but would introduce latencies) you should be OK. (Update: fortunately not true; the Arc would be dropped when you call unsubscribe actually, not from within the ISR).

But the easiest and most safe (if there is anything safe w.r.t. ISRs) method to work with a Queue instance is to just put it in a 'static context with static_cell.

[ivmarkov]

I have a few comments that might improve the example - particularly removing new_borrowed which IMO is completely unnecessary. But if you don't have time/will to fix, merge as-is. We might rework later, or I can just do a follow-up push.

[ivmarkov]

Nit - as per my comment in the main PR thread, this is just not necessary. Just borrowing the queues with e.g. &queue_send and &queue_recv is good enough.

[ivmarkov]

Since & is copy (unlike &mut) you can just push the references into subscribe.

• If indeed subscribe is called, then & need to be transmuted to &'static OR cast to *const Queue<u8> (same outcome)
• If you use subscribe_nonstatic here, none of the above ^^^ would be necessary, as *_nonstatic can use nonstatic borrows (but yes, don't core::mem::forget it then, but your example is even now un-"forgettable" because new_borrowed is just a hyper-complex way to type & and then unsafely transmute the & lifetime to whatever you want)
• Finally, if you just Arc the queues (or even better, put then in a 'static context with static_cell) also none of the above would be necessary and you can keep the usage of subscribe as opposed to switching to subscribe_nonstatic.

[ivmarkov]

Can't we expose this as a safe method?

[ivmarkov]

Also possibly wrong (but not urgent to fix) issues in queue.rs I've missed during the original review:

    pub struct Queue<T> {
        ptr: sys::QueueHandle_t,
        is_owned: bool,
        _marker: PhantomData<T>, // Should be `PhantomData<fn() -> T>` instead
    }

unsafe impl<T> Send for Queue<T> where T: Send + Sync {} // T: Send + Sync probably not necessary, because T is Copy already; and in general T: Send should be enough if T was NOT copy
unsafe impl<T> Sync for Queue<T> where T: Send + Sync {} // Ditto

[Vollbrecht]

yeah i will clean it up a bit later, we should get rid of the new_borrowd stuff.