If I’ve read your docs correctly you need to put a `cyclic()` check in your destructors to prevent UB. That’s not just working on recompilation.

Jonathan Tanner

On 5 Aug 2021, at 9:02 pm, Phil Bouchard via Std-Proposals <std-proposals@lists.isocpp.org> wrote:

On 8/5/21 3:41 PM, Miguel Ojeda wrote:
On Thu, Aug 5, 2021 at 9:01 PM Phil Bouchard <boost@fornux.com> wrote:
Root Pointer is thread safe as shown in my examples.
That is not the point. Rust prevents UB in all safe code. "Root
Pointer" being thread-safe is irrelevant: it does not prevent UB in
the rest of the code.

I'll read more about the data races later, but general race conditions aren't gone with Rust:
Given you are unaware of what Rust brings to the table, please stop
claiming your system is "way better" for the kernel.

Root Pointer is a memory manager. You can add whatever you want to prevent data races:


Each one of them is derived from the other so you can use it as a simple shared_ptr, or cyclic-safe shared_ptr. The latter is just sizeof(void *) x 2. Kernel programmers should be smart enough to use a unique type for iterators. My implementation is just very generic.
The claim you made was that your system works for *existing* code with
a simple recompilation as an argument versus "learning Rust"... If
kernel developers need to start discriminating pointers, use smart
pointers or other annotations, or reimplement anything, then your
argument does not work anymore.

My working method is:

1) Make things work;

2) Optimize.

As I said in the other post all the developers needs to know is whether their data is shared across modules or not; for optimization purposes.


Phil Bouchard
Founder & CTO
C.: (819) 328-4743

Fornux Logo
Std-Proposals mailing list