Implement Models using hazard pointers

[DaMilyutin]

Hi.
I occasonally met online coding session (it is actually 4th) about implementing Hazard pointers in Rust
https://www.youtube.com/watch?v=3oL1xokuHBE

There are also a bunch of links below video, like CS papers and github to Folly (C++ library from Facebook).
I'm not sure if it is best option for implementing Models but looks viable.

BR

[ogoffart]

The model currently must only be accessed in the GUI thread. It is neither Send not Sync.
Hazard pointers is a way to do lock free programming, which is only making sense when working with highly concurrent data structures.
If we would want to make our code more thread friendly, we would start by using locks.
Then maybe later, as an optimization, we could try to do lockfree. But i don't think this is worth it at this point.

[DaMilyutin]

@ogoffart, what do you think about pattern when I pass references to data defined in main (GUI thread by now) to some worker thread and then call invoke_from_event_loop from there which captures references again?
To pass references to those data to other threads Arc+Mutex are required by idiomatic Rust.

But all updates are made in gui thread. So just some sort of universal wrapper or handle to be passed between threads but unwrapped only in event loop will do.

Is it possible to have such kind of "Cell"?

[Be-ing]

Because SixtyFPS models are neither Send nor Sync, you'll need to duplicate data between the GUI models and your lock free backend. I am working on a realtime audio application with SixtyFPS that does this. Take a look at https://codeberg.org/Be.ing/moire/src/branch/main/src/gui.rs. In the callbacks reacting to GUI changes, I am manipulating the SixtyFPS models and sending messages over rtrb channels to manipulate the data that the realtime thread uses. The producer side of the rtrb channel from GUI to realtime thread is wrapped in Rc<RefCell<_>> so I can capture weak pointers in the SixtyFPS callbacks.

[DaMilyutin]

@Be-ing, Thanks for sharing!
So you suggest me to use it in another direction: from thread to gui?
What confuses me is I will probably have multiple worker threads and I need to send from them into gui thread.
Ex. reading many files and sending progress from each one to some list item in gui.

BTW, I fnd your pattern with wrapping MainWindow into struct with some extras very nice. I'll definetly borrow it. 😄

[Be-ing]

So you suggest me to use it in another direction: from thread to gui?

I am using rtrb::RingBuffers in both directions. My application is in an early proof-of-concept stage still at this point. Soonish I will get to integrating MIDI and HID controllers, which will make the communication between threads (controller, audio, and GUI) significantly more complicated. I don't know how I am going to handle that yet. Unfortunately there are not many examples of Rust GUI applications with a realtime thread to look at for inspiration, so I guess I'll have to figure that out as I go. There are a lot of useful crates available. You may try looking through the concurrency category on lib.rs for data structures appropriate for your use case.